h$x r      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU V W X Y Z [ \ ] ^ _ ` abcdefghijklmnopqrstuvwxyz{|}~                            Safe-Inferred0None./  capabilityCompose two accessors.This is not necessary in deriving via clauses, but in places where a transformer is expected as a type argument. E.g. . capability,Skip one level in a monad transformer stack.Note, that instances generated with this strategy can incur a performance penalty.Example: newtype MyStates a = MyStates (StateT Int (State Bool) a) deriving (HasState "foo" Bool) via Lift (StateT Int (MonadState (State Bool)))  Uses the  instance of  StateT Int to lift the  "foo" Bool instance of the underlying  (State Bool) over the  StateT Int monad transformer. capability8Choose the given constructor in the sum-type in context m.Example: data MyError = ErrA String | ErrB String newtype MyExcept a = MyExcept (ExceptT MyError Identity a) deriving (HasThrow "ErrB" String) via Ctor "ErrB" () (MonadError (ExceptT MyError Identity))  Converts the  () "MyError" instance of  (ExceptT MyError Identity) to a  "ErrB" String instance by wrapping thrown String s in the ErrB constructor. capabilityAccess the value at position pos in the context m.Example: newtype MyReader a = MyReader (Reader (Int, Bool) a) deriving (HasReader 1 Int) via Pos 1 () (MonadReader (Reader (Int, Bool)))  Converts the   () (Int, Bool) instance of   (Reader (Int, Bool)) to a   1 Int9 instance by focusing on the first element of the tuple.The implied number tag can be renamed to a more descriptive name using the  combinator: newtype MyReader a = MyReader (Reader (Int, Bool) a) deriving (HasReader "foo" Int) via Rename 1 (Pos 1 () (MonadReader (Reader (Int, Bool))))  capabilityAccess the record field field in the context m.Example: data Foo = Foo { foo :: Int } newtype MyReader a = MyReader (Reader Foo a) deriving (HasReader "foo" Int) via Field "foo" () (MonadReader (Reader Foo))  Converts the   () Foo instance of   (Reader Foo) to a   "foo" Int$ instance by focusing on the field foo in the Foo record.See  for a way to change the tag. capabilityRename the tag.Example: newtype MyReader a = MyReader (Reader Int a) deriving (HasReader "foo" Int) via Rename "bar" (MonadReader (Reader Int))  Converts the   "bar" Int instance of   (Reader Int) to a   "foo" Int instance by renaming the tag. Note, that  ! itself does not fix a tag, and Rename is redundant in this example.See  below for a common use-case. capabilityCoerce the type in the context m to to.Example: newtype MyInt = MyInt Int newtype MyReader a = MyReader (Reader Int a) deriving (HasReader "a" MyInt) via Coerce MyInt (MonadReader (Reader Int))  Converts the   "a" Int instance of   (Reader Int) to a   "a" MyInt instance using Coercible Int MyInt.   9 9  Safe-Inferred '(-./> capabilityType family used used to express a conjunction of constraints over a single type. Examples: All '[Num, Eq] Int -- Equivalent to: (Num Int, Eq Int) All '[HasReader "foo" Int, HasSink "bar" Float] m -- Equivalent to: (HasReader "foo" Int m, HasSink "bar" Float m)? capabilityA ? takes a type constructor  Type -> Type (e.g., a monad) and returns a #. Examples of capabilities includ: HasReader "foo" Int, MonadIO, @ >?>? None -/@ capability5Runs an action that requires additional capabilities.@ @t @derived @ambient act runs act( by providing both the capabilities in derived and ambient. The difference is that ambient4 capabilities are assumed to be available, whereas derived instances are provided by t.@ assumes that t" is a newtype defined in the form: newtype T m a = T (m a) Then @ uses type-class instances for T- to provide for each of the capabilities in derived.A common instance of this is  , whereby exceptions raised by act. can be repackaged in a larger exception type.The derive3 function is experimental and is subject to change.@@None-./?"A capability Reflected s capability m$Carries the type class instance for  capability in the monad m) defined by the dictionary reflected in s in the type system.For most use-cases it is not necessary to use this type directly. Use D or E instead.If you wish to enable reflection for a new capability, then you will need to define a type class instance for  Reflected for the new capability. Note, you will also need to define an instance of C which defines the dictionary type of the new capability. Hint, you can use F @s to obtain the dictionary from the context in the instance implementation.For example, the  Reflected instance for the  capability can be defined as follows. Assuming the dictionary described in C.:{ instance; (Monad m, Reifies s (Reified tag (HasSink tag a) m)) =>1 HasSink tag a (Reflected s (HasSink tag a) m) where- yield a = Reflect $ _yield (reified @s) a :}C capability Reified tag capability m/Defines the dictionary type for the methods of  capability under tag in the monad m . Refer to D for an example use-case.For example, the  capability has the method  :: a -> m ();. The corresponding dictionary type is defined as follows.:{/ data instance Reified tag (HasSink tag a) m =1 ReifiedSink { _yield :: forall a. a -> m () } :}Superclass dictionaries are represented as nested records. For example, the " capability has the superclasses  and  and the method  :: (s -> (a, s)) -> m a;. The corresponding dictionary type is defined as follows.:{0 data instance Reified tag (HasState tag s) m = ReifiedState8 { _stateSource :: Reified tag (HasSource tag s) m,4 _stateSink :: Reified tag (HasSink tag s) m,0 _state :: forall a. (s -> (a, s)) -> m a } :}D capability interpret_ @tag dict actionExecute action1 using the ad-hoc interpretation of a capability c under tag defined by dict, where dict is a value of type C tag c, i.e. a record providing the implementation of the methods of capability c.For example, the following provides an ad-hoc interpretation for the  capability.:{ interpret_ @"my-source"2 ReifiedSource { _await = pure "capabilities" }' (replicateM 3 (await @"my-source")) :}0["capabilities", "capabilities", "capabilities"]E capability #interpret @tag @ambient dict actionLike D' but forwards the ambient capabilities ambient into the context of action as well.For example, the following provides an ad-hoc interpretation for the % capability, while using an ambient  capability.:{5 interpret @"my-source" @'[HasSink "my-sink" String]2 ReifiedSource { _await = pure "capabilities" }= (replicateM_ 3 (await @"my-source" >>= yield @"my-sink")) :}F capability  reified @sObtain the dictionary that is reflected in the type system under s.%This is a convenience wrapper around  .  ABCDEF DECABF None-./2<=>?$J capabilitySinking capability.An instance does not need to fulfill any additional laws besides the monad laws.K capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of J#. Otherwise, you will want to use N. See N for more documentation.N capability yield @tag a emits a in the sink capability tag.CLMJKNNone-./2<=>?'rO capabilitySourcing capability.An instance does not need to fulfill any additional laws besides the monad laws.P capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of O#. Otherwise, you will want to use S. See S for more documentation.S capability await @tag a takes a from the source capability tag.T capability awaits @tag retrieves the image by f. of the environment of the reader capability tag. awaits @tag f = f <$> await @tagCQROPSTNone./0>?/U capabilityReader capabilityAn instance should fulfill the following laws. At this point these laws are not definitive, see  'https://github.com/haskell/mtl/issues/5.k <*> ask @t = ask @t <**> kask @t *> m = m = m <* ask @t%local @t f (ask @t) = fmap f (ask @t)*local @t f . local @t g = local @t (g . f)local @t f (pure x) = pure xlocal @t f (m >>= \x -> k x) = local @t f m >>= \x -> local @t f (k x)reader @t f = f <$> ask @tV capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of U#. Otherwise, you will want to use ^. See ^ for more documentation.W capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of U#. Otherwise, you will want to use _. See _ for more documentation.\ capabilityask @tag5 retrieves the environment of the reader capability tag.] capability asks @tag retrieves the image by f. of the environment of the reader capability tag.asks @tag f = f <$> ask @tag^ capabilitylocal @tag f m runs the monadic action m in a modified environment e' = f e , where e- is the environment of the reader capability tag. Symbolically: return e = ask @tag._ capabilityreader @tag act. lifts a purely environment-dependent action act, to a monadic action in an arbitrary monad m with capability  HasReader.It happens to coincide with asks:  reader = asks.` capabilityExecute the given reader action on a sub-component of the current context as defined by the given transformer t., retaining arbitrary capabilities listed in cs.See the similar  ) function for more details and examples.:This function is experimental and subject to change. See  -https://github.com/tweag/capability/issues/46.CQXRYZ[UVW\]^_`!None./0>?9q a capabilityState capabilityAn instance should fulfill the following laws. At this point these laws are not definitive, see  'https://github.com/haskell/mtl/issues/5.get @t >>= \s1 -> get @t >>= \s2 -> pure (s1, s2) = get @t >>= \s -> pure (s, s)$get @t >>= \_ -> put @t s = put @t s"put @t s1 >> put @t s2 = put @t s2'put @t s >> get @t = put @t s >> pure sstate @t f = get @t >>= \s -> let (a, s') = f s in put @t s' >> pure ab capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of 'HasState. Otherwise, you will want to use i. See i for more documentation.g capabilityget @tag5 retrieve the current state of the state capability tag.h capability put @tag s4 replace the current state of the state capability tag with s.i capability state @tag f! lifts a pure state computation f, to a monadic action in an arbitrary monad m with capability HasState.Given the current state s of the state capability tag and  (a, s') = f s, update the state to s' and return a.j capability modify @tag f given the current state s of the state capability tag and s' = f s&, updates the state of the capability tag to s'.k capabilitySame as j but strict in the new state.l capability gets @tag f retrieves the image, by f/ of the current state of the state capability tag.gets @tag f = f <$> get @tagm capabilityExecute the given state action on a sub-component of the current state as defined by the given transformer t. The set of retained capabilities must be passed as @cs. If no capabilities are required, "# can be used. Examples: foo :: HasState "foo" Int m => m () zoom @"foo" @(Field "foo" "foobar") @None foo :: (HasField' "foobar" record Int, HasState "foobar" record m) => m () zoom @"foo" @(Field "foo" "foobar") @('[MonadIO]) bar :: ( HasField' "foobar" record Int, HasState "foobar" record m , MonadIO m) => m () foo :: HasState "foo" Int m => m () bar :: (MonadIO m, HasState "foo" Int m) => m () Note: the $% constraint comes from the  generic-lens package.:This function is experimental and subject to change. See  -https://github.com/tweag/capability/issues/46.CLQcMRdefabghijklm&None'(-./2<=>?=n capability HasState "foo" Int (MyState m)See p for a specialized version over +,.p capability+Derive a state monad from a reader over an +,.Example: newtype MyState m a = MyState (ReaderT (IORef Int) m a) deriving (Functor, Applicative, Monad) deriving HasState "foo" Int via ReaderIORef (MonadReader (ReaderT (IORef Int) m))See n for a more generic strategy.r capabilityDerive HasState from m's - instance.nopqrs.None'(-./2<=>?@t capability*Convert a state monad into a reader monad.7Use this if the monad stack allows catching exceptions.See v.v capability Convert a pure! state monad into a reader monad.Pure meaning that the monad stack does not allow catching exceptions. Otherwise, an exception occurring in the action passed to local could cause the context to remain modified outside of the call to local. E.g. local @tag (const r') (throw MyException) `catch` \MyException -> ask @tagreturns r' instead of the previous value.Note, that no MonadIO instance is provided, as this would allow catching exceptions.See t.x capabilityDerive O from m's / instance. capabilityRename the tag. nopqrstuvwxy0None./02<=>B capability,Lift one layer in a monad transformer stack. capability!Zoom in on the field at position pos of type v in the environment struct. capabilityZoom in on the record field field of type v in the environment record. capabilityRename the tag. capability,Convert the environment using safe coercion. capabilityCompose two accessors.tuvwxy1None-./2<=>?I z capability-Accumulate sunk values with their own monoid.| capability=Accumulate sunk values in forward order in a difference list.~ capability/Accumulate sunk values in a reverse order list. capability!Zoom in on the field at position pos of type v in the state struct. capabilityZoom in on the record field field of type v in the state record. capabilityRename the tag. capability&Convert the state using safe coercion. capability,Lift one layer in a monad transformer stack.Note, that if the J instance is based on a&, then it is more efficient to apply < to the underlying state capability. E.g. you should favour deriving (HasSink tag w) via SinkLog (Lift (SomeTrans (MonadState SomeStateMonad)))over deriving (HasSink tag w) via Lift (SomeTrans (SinkLog (MonadState SomeStateMonad))) capabilityThis instance may seem a bit odd at first. All it does is wrap each Ned value in a single element difference list. How does re-yielding something else constitute a strategy for implementing J in the first place? The answer is that difference lists form a monoid, which allows a second stragegy to be used which accumulates all N/s in a single value, actually eliminating the J constraint this time.z below in fact does this, so the easiest way to fully eliminate the J" constraint as described above is: deriving (HasSink tag w) via SinkDList (SinkLog (MonadState SomeStateMonad)) capabilityCompose two accessors.z{|}~2None./02<=>KX capability,Lift one layer in a monad transformer stack. capability!Zoom in on the field at position pos of type v in the state struct. capabilityZoom in on the record field field of type v in the state record. capabilityRename the tag. capability&Convert the state using safe coercion. capabilityCompose two accessors.nopqrs  Safe-Inferred./O capabilityType family associating a tag to the corresponding type. It is intended to simplify constraint declarations, by removing the need to redundantly specify the type associated to a tag.It is poly-kinded, which allows users to define their own kind of tags. Standard haskell types can also be used as tags by specifying the . kind when defining the type family instance. Defining  instances for 34s (typelevel string literals) is discouraged. Since symbols all belong to the same global namespace, such instances could conflict with others defined in external libraries. More generally, as for typeclasses,  instances should always be defined in the same module as the tag type to prevent issues due to orphan instances.Example:  import Capability.Reader data Foo data Bar type instance TypeOf Type Foo = Int type instance TypeOf Type Bar = String -- Same as: foo :: HasReader Foo Int M => @ foo :: HasReader' Foo m => @ foo = @ None-./PX capabilityType synonym using the  type family to specify a constraints without having to specify the type associated to a tag.( CcLQfedMRabghijklmnopqrsabghijklmCLQcMRdefrspqnoNone-./2<=>?Qv capabilityType synonym using the  type family to specify O constraints without having to specify the type associated to a tag.# CQROPSTnopqrstuvwxyOPSTxyvwturspqnoNone-.Rh capabilityType synonym using the  type family to specify J constraints without having to specify the type associated to a tag. CLMJKNz{|}~ JKN~|}z{ None-.R NN None-./S capabilityType synonym using the  type family to specify U constraints without having to specify the type associated to a tag.% CQX[ZRYUVW\]^_`tuvwxyUVW\]^_`CQXRYZ[xyvwtuNone-./02<=>c capabilityType synonym using the  type family to specify  constraints without having to specify the type associated to a tag. capabilityType synonym using the  type family to specify  constraints without having to specify the type associated to a tag. capabilityDerive HasError" using the functionality from the unliftio package. capabilityDerive HasError" using the functionality from the safe-exceptions package. capabilityDerive 'HasCatch from m,'s 'Control.Monad.Catch.MonadCatch instance. capabilityDerive  from m's 56 instance. capabilityDerive 'HasError from m's 7 instance. capability'Capability to catch exceptions of type e under tag.HasThrow/HasCatch capabilities at different tags should be independent. In particular, the following program should throw  SomeError and not return (). > example :: > (HasThrow Left SomeError m, HasCatch Right3 SomeError m) > => m () > example = > catch Left > (throw Right SomeError) > _ -> pure ()See 8 for a way to combine multiple exception types into one. capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of  HasReader#. Otherwise, you will want to use . See  for more documentation. capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of  HasReader#. Otherwise, you will want to use . See  for more documentation. capability'Capability to throw exceptions of type e under tag.HasThrow/HasCatch< capabilities at different tags should be independent. See . capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of  HasReader#. Otherwise, you will want to use . See  for more documentation. capability9Throw an exception in the specified exception capability. capabilityProvide a handler for exceptions thrown in the given action in the given exception capability. capabilityLike , but only handle the exception if the provided function returns . capabilityWrap exceptions inner> originating from the given action according to the accessor t*. Retain arbitrary capabilities listed in cs.Example: wrapError @"ComponentError" @(Ctor "ComponentError" "AppError") @'[] component component :: HasError "ComponentError" ComponentError m => m () data AppError = ComponentError ComponentError:This function is experimental and subject to change. See  -https://github.com/tweag/capability/issues/46. capability,Lift one layer in a monad transformer stack. capabilityWrap the exception e with the constructor ctor to throw an exception of type sum. capabilityRename the tag.Apply cautiously. See  newtag e ( oldtag m). capability,Lift one layer in a monad transformer stack. capabilityCatch an exception of type sum if its constructor matches ctor. capabilityRename the tag.Apply cautiously. E.g. the following code produces colliding instances, where exceptions thrown in "Foo"4 cannot be distinguished from exceptions thrown in "Bar" and vice-versa. newtype Bad a = Bad (IO a) deriving (Functor, Applicative, Monad) deriving ( HasThrow "Foo" m , HasCatch "Foo" m ) via Rename () (MonadUnliftIO SomeError IO) deriving ( HasThrow "Bar" m , HasCatch "Bar" m ) via Rename () (MonadUnliftIO SomeError IO) capabilityCompose two accessors. capabilityCompose two accessors.0 C"C None-./02<=>p>  capabilityType synonym using the  type family to specify  constraints without having to specify the type associated to a tag. capabilityWriter capabilityAn instance should fulfill the following laws. At this point these laws are not definitive, see  'https://github.com/haskell/mtl/issues/5.%listen @t (pure a) = pure (a, mempty)0listen @t (tell @t w) = tell @t w >> pure (w, w)listen @t (m >>= k) = listen @t m >>= \(a, w1) -> listen @t (k a) >>= \(b, w2) -> pure (b, w1 `mappend` w2)> pure (a, f)) = tell @t (f w) >> pure a&writer @t (a, w) = tell @t w >> pure aA note on the J super class.J offers one N# method with the same signature as ?. Many people's intuition, however, wouldn't connect the two: N7ing tosses the value down some black-box chute, while ing grows and accumulation via the monoid. The connection is since the chute is opaque, the tosser cannot rule out there being such an accumulation at the chutes other end.(Formally, we reach the same conclusion. J has no laws, indicating the user can make no assumptions beyond the signature of N. , with  defined as N, is thus always compatable regardless of whatever additional methods it provides and laws by which it abides. capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of  HasReader#. Otherwise, you will want to use . See  for more documentation. capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of  HasReader#. Otherwise, you will want to use . See  for more documentation. capabilityFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of  HasReader#. Otherwise, you will want to use . See  for more documentation. capabilitywriter @tag (a, w) lifts a pure writer action (a, w), to a monadic action in an arbitrary monad m with capability  HasWriter.Appends w( to the output of the writer capability tag and returns the value a. capability tell @tag w appends w( to the output of the writer capability tag. capability listen @tag m executes the action m and returns the output of m in the writer capability tag along with result of m. Appends the output of m( to the output of the writer capability tag. capability pass @tag m executes the action m . Assuming m returns (a, f) and appends w( to the output of the writer capability tag.  pass @tag m instead appends w' = f w to the output and returns a. capabilityCompose two accessors.* CLQcMRdefz{z{CLQcMRdef None 0>r capability,Lift one layer in a monad transformer stack.Note, that if the  instance is based on HasState&, then it is more efficient to apply < to the underlying state capability. E.g. you should favour deriving (HasWriter tag w) via WriterLog (Lift (SomeTrans (MonadState SomeStateMonad)))over deriving (HasWriter tag w) via Lift (SomeTrans (WriterLog (MonadState SomeStateMonad)))89:;<=8>?8>@8>A8>B8CD8CDEFGEFGHIJHIKHILMMNNOOPPQQRRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!!!!!!!!!!!!! &&&&&&......111111       66                    '.0000001111111222222;<8capability-0.4.0.0-inplaceCapability.ErrorCapability.ConstraintsCapability.ReflectionCapability.AccessorsCapability.DeriveCapability.SinkCapability.StateCapability.SourceCapability.ReaderCapability.TypeOfCapability.StreamCapability.WriterCapability.Writer.Discouraged CapabilityHasError wrapErrorControl.Monad.Trans.Class MonadTransHasState MonadStateHasThrow MonadError HasReader MonadReaderHasSinkyield HasSourcestateCapability.Sink.Internal.Class Capability.Source.Internal.Class Capability.Reader.Internal.ClasszoomCapability.State.Internal.ClassCapabilities.ConstraintsNoneData.Generics.Product.Fields HasField'+Capability.State.Internal.Strategies.CommonControl.Monad.Primitive PrimState Data.MutableMCState Data.IORefIORefControl.Monad.State.Class%Capability.Source.Internal.StrategiesControl.Monad.Reader.Class%Capability.Reader.Internal.Strategies#Capability.Sink.Internal.Strategies$Capability.State.Internal.Strategies GHC.TypeLitsSymbolControl.Monad.Catch MonadThrowControl.Monad.ExceptbaseData.Typeable.InternalTypeableghc-prim GHC.Types ConstraintGHC.Exception.TypedisplayException fromException toException Exception Data.ProxyProxy'constraints-0.12-6e5ay0bRGcjEeuCf34GoIQData.ConstraintDict'reflection-2.1.6-4ZV0dCLPUM9IqXJWa3PlSJData.ReflectionreifyreflectReifies:.:LiftCtorPosFieldRenameCoerce $fFunctor:.:$fApplicative:.: $fMonad:.: $fMonadIO:.:$fPrimMonad:.: $fFunctorLift$fApplicativeLift $fMonadLift $fMonadIOLift$fPrimMonadLift $fFunctorCtor$fApplicativeCtor $fMonadCtor $fMonadIOCtor$fPrimMonadCtor $fFunctorPos$fApplicativePos $fMonadPos $fMonadIOPos$fPrimMonadPos$fFunctorField$fApplicativeField $fMonadField$fMonadIOField$fPrimMonadField$fFunctorRename$fApplicativeRename $fMonadRename$fMonadIORename$fPrimMonadRename$fFunctorCoerce$fApplicativeCoerce $fMonadCoerce$fMonadIOCoerce$fPrimMonadCoerceAllderive ReflectedReflectReified interpret_ interpretreified$fFunctorReflected$fApplicativeReflected$fMonadReflectedyield_ ReifiedSink_yieldawait_ ReifiedSource_awaitawaitawaitslocal_reader_ ReifiedReader _readerSource_local_readeraskaskslocalreadermagnifystate_ ReifiedState _stateSource _stateSink_stategetputmodifymodify'gets ReaderRef ReaderIORef ReadState ReadStatePureSinkLog SinkDList SinkStackTypeOf HasState' HasSource'HasSink' HasStream' StreamLog StreamDList StreamStack HasStream HasReader' HasCatch' HasThrow' MonadUnliftIOSafeExceptions MonadCatchHasCatchcatch_ catchJust_throw_ ReifiedCatch _catchThrow_catch _catchJust ReifiedThrow_throwthrowcatch catchJust$fHasThrowktageReflected$fHasThrowktageLift$fHasThrowSymbolctoreCtor$fHasThrowknewtageRename$fHasCatchktageReflected$fHasThrowktageReflected0$fHasCatchktageLift$fHasCatchSymbolctoreCtor$fHasCatchknewtageRename$fHasCatchktageMonadError$fHasThrowktageMonadError$fHasThrowktageMonadThrow$fHasCatchktageMonadCatch$fHasCatchktageSafeExceptions$fHasThrowktageSafeExceptions$fHasCatchktageMonadUnliftIO$fHasThrowktageMonadUnliftIO$fFunctorMonadUnliftIO$fApplicativeMonadUnliftIO$fMonadMonadUnliftIO$fMonadIOMonadUnliftIO$fPrimMonadMonadUnliftIO$fFunctorSafeExceptions$fApplicativeSafeExceptions$fMonadSafeExceptions$fMonadIOSafeExceptions$fPrimMonadSafeExceptions$fFunctorMonadCatch$fApplicativeMonadCatch$fMonadMonadCatch$fMonadIOMonadCatch$fPrimMonadMonadCatch$fHasThrowktageMonadCatch$fFunctorMonadThrow$fApplicativeMonadThrow$fMonadMonadThrow$fMonadIOMonadThrow$fPrimMonadMonadThrow$fFunctorMonadError$fApplicativeMonadError$fMonadMonadError$fMonadIOMonadError$fPrimMonadMonadError$fHasCatchktage:.:$fHasThrowktage:.: HasWriter' WriterLog HasWriterwriter_listen_pass_ ReifiedWriter _writerSink_writer_listen_passwritertelllistenpass$fHasWriterktagwReflected$fHasSinkktagwReflected$fHasWriterktagwSinkLog$fHasWriterktagw:.:$fHasWriterTYPEtagwLift'primitive-0.7.1.0-Jxsyd70oUttYiCXCa0HqV PrimMonad$fHasSourceknewtagrRename$fHasReaderktagrLift$fHasReaderNattagvPos$fHasReaderSymboltagvField$fHasReaderknewtagrRename$fHasReaderktagtoCoerce$fHasReaderktagr:.:$fHasSinkNattagvPos$fHasSinkSymboltagvField$fHasSinkknewtagsRename$fHasSinkktagtoCoerce$fHasSinkktagaLift$fHasSinkktagaSinkDList$fHasSinkktaga:.:$fHasStatektagsLift$fHasStateNattagvPos$fHasStateSymboltagvField$fHasStateknewtagsRename$fHasStatektagtoCoerce$fHasStatektags:.:Type GHC.MaybeJust