úÎ!nPb¾¼      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef ghij k l m n opqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º »  Safe ÎNone-.HMUV5ú capabilityCompose two accessors.wThis 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.SNote, 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.LThe 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 &',-.HUV=é9 capabilityRType 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 * -> * (e.g., a monad) and returns a #. Examples of capabilities includ: HasReader "foo" Int, MonadIO, &9:9:None ,.HSUVXkqHÁ; 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,-.1;<=>?@ACFHMUVXkqOÎ< capabilitySinking capability.QAn instance does not need to fulfill any additional laws besides the monad laws.= capabilityyFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of <#. Otherwise, you will want to use >. See > for more documentation.> capability yield @tag a emits a in the sink capability tag.<=>None,-.1;<=>?@ACFHMUVXkqY? capabilitySourcing capability.QAn instance does not need to fulfill any additional laws besides the monad laws.@ capabilityyFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of ?#. Otherwise, you will want to use A. See A for more documentation.A capability await @tag a takes a from the source capability tag.B capability awaits @tag retrieves the image by f. of the environment of the reader capability tag. awaits @tag f = f <$> await @tag?@ABNone-.@ACFHSUVXkqvC capabilityReader capabilitybAn 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 xFlocal @t f (m >>= \x -> k x) = local @t f m >>= \x -> local @t f (k x)reader @t f = f <$> ask @tD capabilityyFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of C#. Otherwise, you will want to use H. See H for more documentation.E capabilityyFor technical reasons, this method needs an extra proxy argument. You only need it if you are defining new instances of C#. Otherwise, you will want to use I. See I for more documentation.F capabilityask @tag5 retrieves the environment of the reader capability tag.G capability asks @tag retrieves the image by f. of the environment of the reader capability tag.asks @tag f = f <$> ask @tagH 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.I 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.J capabilityoExecute 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.CDEFGHIJNone-.@ACFHSUVXkq™‰ K capabilityState capabilitybAn instance should fulfill the following laws. At this point these laws are not definitive, see  'https://github.com/haskell/mtl/issues/5.Pget @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 sFstate @t f = get @t >>= \s -> let (a, s') = f s in put @t s' >> pure aL capability¥For 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 O. See O for more documentation.M capabilityget @tag5 retrieve the current state of the state capability tag.N capability put @tag s4 replace the current state of the state capability tag with s.O 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.P 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'.Q capabilitySame as P but strict in the new state.R capability gets @tag f retrieves the image, by f/ of the current state of the state capability tag.gets @tag f = f <$> get @tagS capabilitylExecute 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. KLMNOPQRS!None&',-.1;<=>?@ACFHMUVXkq¨¥T capability<Derive a state monad from a reader over a mutable reference.&Mutable references are available in a ¼. The corresponding "# has to match the $%R of the reference. This constraint makes a stand-alone deriving clause necessary.Example: önewtype MyState m a = MyState (ReaderT (IORef Int) m a) deriving (Functor, Applicative, Monad) deriving via ReaderRef (MonadReader (ReaderT (IORef Int) m)) instance (PrimMonad m, PrimState m ~ PrimState IO) => HasState "foo" Int (MyState m)See V for a specialized version over &'.V 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 T for a more generic strategy.X capabilityDerive HasState from m's ( instance.TUVWXY)None&',-.1;<=>?@ACFHMUVXkq´—Z capability*Convert a state monad into a reader monad.7Use this if the monad stack allows catching exceptions.See \.\ 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 localD could cause the context to remain modified outside of the call to local. E.g. Jlocal @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 Z.^ capabilityDerive ? from m's * instance.½ capabilityRename the tag. TUVWXYZ[\]^_+None-./1;<=?@AFHMSUVXgkq»\¾ 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.Z[\]^_,None,-.1;<=>?@ACFHMUVXkqÓ? ` capability-Accumulate sunk values with their own monoid.b capability=Accumulate sunk values in forward order in a difference list.d 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 < instance is based on K&, then it is more efficient to apply  < to the underlying state capability. E.g. you should favour Uderiving (HasSink tag w) via SinkLog (Lift (SomeTrans (MonadState SomeStateMonad)))over Uderiving (HasSink tag w) via Lift (SomeTrans (SinkLog (MonadState SomeStateMonad)))É capabilityEThis instance may seem a bit odd at first. All it does is wrap each >zed value in a single element difference list. How does re-yielding something else constitute a strategy for implementing <Š in the first place? The answer is that difference lists form a monoid, which allows a second stragegy to be used which accumulates all >/s in a single value, actually eliminating the < constraint this time.`E below in fact does this, so the easiest way to fully eliminate the <" constraint as described above is: Nderiving (HasSink tag w) via SinkDList (SinkLog (MonadState SomeStateMonad))Ê capabilityCompose two accessors.`abcde-None-./1;<=?@AFHMSUVXkqÙ”Ë 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.TUVWXY Safe-.HVévf capability¸Type 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 f instances for ./Õs (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, fs 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 * Foo = Int type instance TypeOf * Bar = String -- Same as: foo :: HasReader Foo Int M => & foo :: HasReader' Foo m => & foo = & ffNone,-.Hëðg capabilityType synonym using the f type family to specify KE constraints without having to specify the type associated to a tag. KLMNOPQRSTUVWXYfgKLMNOPQRSgfXYVWTUNone,-.1;<=>?@ACFHMUVXkqïÂh capabilityType synonym using the f type family to specify ?E constraints without having to specify the type associated to a tag.  ?@ABTUVWXYZ[\]^_fh?@ABhf^_\]Z[XYVWTUNone,-FHòôi capabilityType synonym using the f type family to specify <E constraints without having to specify the type associated to a tag. <=>`abcdefi <=>ifdebc`a None,-HóÒ >jklmnnj>mlkNone,-.Hö¬o capabilityType synonym using the f type family to specify CE constraints without having to specify the type associated to a tag. CDEFGHIJZ[\]^_foCDEFGHIJof^_\]Z[None,-./1;<=?@ACFHMSUVXkq/—p capabilityType synonym using the f type family to specify |E constraints without having to specify the type associated to a tag.q capabilityType synonym using the f type family to specify E constraints without having to specify the type associated to a tag.r capabilityDerive HasError" using the functionality from the unliftio package.t capabilityDerive HasError" using the functionality from the safe-exceptions package.v capabilityDerive 'HasCatch from m,'s 'Control.Monad.Catch.MonadCatch instance.x capabilityDerive  from m's 01 instance.z capabilityDerive 'HasError from m's 2 instance.| capability'Capability to catch exceptions of type e under tag.HasThrow/HasCatchj 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.} capabilityyFor 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.~ capabilityyFor 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 |.€ capabilityyFor 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.‚ capability_Provide a handler for exceptions thrown in the given action in the given exception capability.ƒ capabilityLike ‚B, 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.dApply 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.) fpqrstuvwxyz{|}~€‚ƒ„€|}~‚ƒ„qpfz{xyvwturs None,-./1;<=?@ACFHMSUVXkq[Y ¯ capabilityType synonym using the f type family to specify ±E constraints without having to specify the type associated to a tag.± capabilityWriter capabilitybAn 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)klisten @t (m >>= k) = listen @t m >>= \(a, w1) -> listen @t (k a) >>= \(b, w2) -> pure (b, w1 `mappend` w2)<pass @t (tell @t w >> pure (a, f)) = tell @t (f w) >> pure a&writer @t (a, w) = tell @t w >> pure aA note on the < super class.< offers one ># method with the same signature as ¶?. Many people's intuition, however, wouldn't connect the two: >7ing tosses the value down some black-box chute, while ¶Hing grows and accumulation via the monoid. The connection is since the chuteb is opaque, the tosser cannot rule out there being such an accumulation at the chutes other end.(Formally, we reach the same conclusion. <S has no laws, indicating the user can make no assumptions beyond the signature of >. ±, with ¶ defined as >p, is thus always compatable regardless of whatever additional methods it provides and laws by which it abides.² capabilityyFor 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.³ capabilityyFor 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.´ capabilityyFor 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. `afk¯°±²³´µ¶·¸±²³´µ¶·¸¯f°k`a None /=?@AFSXkbº» 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 Yderiving (HasWriter tag w) via WriterLog (Lift (SomeTrans (MonadState SomeStateMonad)))over Yderiving (HasWriter tag w) via Lift (SomeTrans (WriterLog (MonadState SomeStateMonad)))Ó34567839:39;39<39=>?@>?@AABBCCDDEEFFGGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk lmnopqrstuvwxyz{|}~€!‚!‚!ƒ!ƒ!!)„)„)…)…)),†,†,‡,‡,ˆ,ˆ ‰Š‹Œ  Ž   ‘’“”••––——11˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈ É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô ÕÖ"×)Ø+Ù+Ú+Û+Ü+Ý+Þ,ß,à,á,â,ã,ä,å-æ-ç-è-é-ê-ë3ìí3îïð)capability-0.3.0.0-BNgTzQvtzyzJtrhI5qExEkCapability.ErrorCapability.ConstraintsCapability.AccessorsCapability.DeriveCapability.SinkCapability.SourceCapability.ReaderCapability.StateCapability.TypeOfCapability.StreamCapability.WriterCapability.Writer.Discouraged CapabilityHasError wrapErrorControl.Monad.Trans.Class MonadTransHasState MonadStateHasThrow MonadError HasReader MonadReaderCapability.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)constraints-0.10.1-7C0OhcwtaPeGTKK8MwqDp0Data.ConstraintDict:.:LiftCtorPosFieldRenameCoerce$fFunctorCoerce$fApplicativeCoerce $fMonadCoerce$fMonadIOCoerce$fPrimMonadCoerce$fFunctorRename$fApplicativeRename $fMonadRename$fMonadIORename$fPrimMonadRename$fFunctorField$fApplicativeField $fMonadField$fMonadIOField$fPrimMonadField $fFunctorPos$fApplicativePos $fMonadPos $fMonadIOPos$fPrimMonadPos $fFunctorCtor$fApplicativeCtor $fMonadCtor $fMonadIOCtor$fPrimMonadCtor $fFunctorLift$fApplicativeLift $fMonadLift $fMonadIOLift$fPrimMonadLift $fFunctor:.:$fApplicative:.: $fMonad:.: $fMonadIO:.:$fPrimMonad:.:AllderiveHasSinkyield_yield HasSourceawait_awaitawaitslocal_reader_askaskslocalreadermagnifystate_getputstatemodifymodify'gets ReaderRef ReaderIORef ReadState ReadStatePureSinkLog SinkDList SinkStackTypeOf HasState' HasSource'HasSink' HasStream' StreamLog StreamDList StreamStack HasStream HasReader' HasCatch' HasThrow' MonadUnliftIOSafeExceptions MonadCatchHasCatchcatch_ catchJust_throw_throwcatch catchJust$fHasThrowktageLift$fHasThrowSymbolctoreCtor$fHasThrowknewtageRename$fHasCatchktageLift$fHasCatchSymbolctoreCtor$fHasCatchknewtageRename$fHasCatchktageMonadError$fHasThrowktageMonadError$fHasThrowktageMonadThrow$fHasCatchktageMonadCatch$fHasCatchktageSafeExceptions$fHasThrowktageSafeExceptions$fHasCatchktageMonadUnliftIO$fHasThrowktageMonadUnliftIO$fFunctorMonadError$fApplicativeMonadError$fMonadMonadError$fMonadIOMonadError$fPrimMonadMonadError$fFunctorMonadThrow$fApplicativeMonadThrow$fMonadMonadThrow$fMonadIOMonadThrow$fPrimMonadMonadThrow$fFunctorMonadCatch$fApplicativeMonadCatch$fMonadMonadCatch$fMonadIOMonadCatch$fPrimMonadMonadCatch$fHasThrowMonadCatch$fFunctorSafeExceptions$fApplicativeSafeExceptions$fMonadSafeExceptions$fMonadIOSafeExceptions$fPrimMonadSafeExceptions$fFunctorMonadUnliftIO$fApplicativeMonadUnliftIO$fMonadMonadUnliftIO$fMonadIOMonadUnliftIO$fPrimMonadMonadUnliftIO $fHasCatch:.: $fHasThrow:.: HasWriter' WriterLog HasWriterwriter_listen_pass_writertelllistenpass$fHasWriterktagwSinkLog$fHasWriter:.:$fHasWriterTYPEtagwLift(primitive-0.6.4.0-ILgywxtLpvnAOlEISPpP5b PrimMonad$fHasSourceknewtagrRename$fHasReaderktagrLift$fHasReaderNattagvPos$fHasReaderSymboltagvField$fHasReaderknewtagrRename$fHasReaderktagtoCoerce$fHasReader:.:$fHasSinkNattagvPos$fHasSinkSymboltagvField$fHasSinkknewtagsRename$fHasSinkktagtoCoerce$fHasSinkktagaLift$fHasSinkktagaSinkDList $fHasSink:.:$fHasStatektagsLift$fHasStateNattagvPos$fHasStateSymboltagvField$fHasStateknewtagsRename$fHasStatektagtoCoerce $fHasState:.:GHC.Num* GHC.MaybeJust