úΑ‹eY      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX Safe-Infered_A simple record containing the resolver functions for all possible coroutine pair suspensions. Eresolves the left suspension functor into the resumption it contains 2resolves the right suspension into its resumption Tinvoked when both coroutines are suspended, resolves both suspensions or either one [Type of functions that can bind two monadic values together; used to combine two coroutines' step results. ^Combines two functors into one, applying either or both of them. Used for coupled coroutines. The   functor instance doesn'Pt contain anything and cannot be constructed. Used for building non-suspendable  coroutines. ,Suspending, resumable monadic computations. Run the next step of a N computation. The result of the step execution will be either a suspension or  the final coroutine result. LCombines two values under two functors into a pair of values under a single Y. Suspend the current . Change the base monad of a . #Change the suspension functor of a . *Modify the first upcoming suspension of a . Convert a non-suspending  to the base monad. $Runs a single step of a suspendable C, using a function that extracts the coroutine resumption from its  suspension functor. Runs a suspendable  to its completion. 'Runs a suspendable coroutine much like <, but allows the resumption function to thread an arbitrary  state as well. A F that runs the two steps sequentially before combining their results. A & that runs the two steps in parallel.  Lifting a  onto a  monad transformer. sWeaves two coroutines into one. The two coroutines suspend and resume in lockstep. The combined coroutine suspends c as long as either argument coroutine suspends, and it completes execution when both arguments do. rWeaves a list of coroutines with the same suspension functor type into a single coroutine. The coroutines suspend  and resume in lockstep. qRuns two coroutines concurrently. The first argument is used to run the next step of each coroutine, the next to R convert the left, right, or both suspensions into the corresponding resumptions. qRuns two coroutines concurrently. The first argument is used to run the next step of each coroutine, the next to @ convert their step results into the corresponding resumptions. '  Z[\]^_`a        Z[\]^_`a Safe-Infered !tThis is a contra-functor data type for selecting a prefix of an input stream. If the next input item is acceptable, W the ticker function returns the ticker for the rest of the stream. If not, it returns b. #'Extracts a list prefix accepted by the !< argument. Returns the modified ticker, the prefix, and the  remainder of the list. $ A ticker that accepts no input. %+A ticker that accepts a single input item. &5A ticker that accepts a given number of input items. '^A ticker that accepts the longest prefix of input that matches a prefix of the argument list. (qA ticker that accepts a prefix of input as long as each item satisfies the predicate at the same position in the g argument list. The length of the predicate list thus determines the maximum number of acepted values. )KA ticker that accepts all input as long as it matches the given predicate. *MA ticker that accepts all input items until one matches the given predicate. +!A ticker that accepts all input. ,qSequential concatenation ticker combinator: when the first argument ticker stops ticking, the second takes over. -_Parallel conjunction ticker combinator: the result keeps ticking as long as both arguments do. .bParallel choice ticker combinator: the result keeps ticking as long as any of the arguments does. !"#$%&'()*+,-.c!"#$%&'()*+,-.!"#$%&'()*+,-.!"#$%&'()*+,-.c Safe-Infered/cCombines two alternative functors into one, applying one or the other. Used for nested coroutines. 3The 3 functor instance combines a 7 of a request with an 5 for a response. 5The 5> functor instance is equivalent to (->) but more descriptive. 7The 7= functor instance is equivalent to (,) but more descriptive. 9Like d" for the EitherFunctor data type. :0Suspend the current coroutine yielding a value. ;9Suspend the current coroutine until a value is provided. <6Suspend yielding a request and awaiting the response. =6Suspend yielding a request and awaiting the response. >UConverts a coroutine yielding collections of values into one yielding single values. ?UConverts a coroutine awaiting single values into one awaiting collections of values. @A 6 for running two coroutines in parallel, one of which ;s values while the other :s G them. The yielding coroutine must not terminate before the other one. AA 6 for running two coroutines in parallel, one of which ;s values while the other :s ] them. If the yielding coroutine terminates before the awaiting one, the latter will receive b. BA 6 for running two coroutines in parallel, one of which ;"s non-empty lists of values while  the other :Us them. If the yielding coroutine dies, the awaiting coroutine receives empty lists. CA  for running two <)ing coroutines in parallel. One coroutine's request becomes the other's  response, and vice versa. DA Z for running two coroutines in parallel. One coroutine produces data in chunks, the other q consumes data in chunks. The boundaries of the two kinds of chunks need not be the same, as the consumed chunks  are determined by a ! provided by the consumer's input request. EA generic version of D, allowing coroutines with 3 and 7 functors embedded in  other functors. FLike DP, the only difference being that the producing coroutine sends its chunks using <  rather than :. The feedback received from <: is the unconsumed remainder of the chunk, which lets the - coroutine know when its sibling terminates. GA generic version of F, allowing coroutines with 3 functors embedded in other  functors. HLike FX, except the consuming coroutine requests receive both the selected prefix of the input Q chunk and a peek at either the next unconsumed input item, if any, or the final ! value. Chunks sent by the t producing coroutine never get combined for the consuming coroutine. This allows better synchronization between the t two coroutines. It also leaks the information about the produced chunk boundaries into the consuming coroutine, so , this resolver should be used with caution. IA generic version of H, allowing coroutines with 3 functors embedded in other  functors. JLike parserYieldResolverP, the only difference being that the producing coroutine sends its chunks using <  rather than :. The feedback received from <: is the unconsumed remainder of the chunk, which lets the - coroutine know when its sibling terminates. KA generic version of J, allowing coroutines with 3 functors embedded in other  functors. LLike JX, except the consuming coroutine requests receive both the selected prefix of the input Q chunk and a peek at either the next unconsumed input item, if any, or the final e value. Chunks sent by the t producing coroutine never get combined for the consuming coroutine. This allows better synchronization between the t two coroutines. It also leaks the information about the produced chunk boundaries into the consuming coroutine, so , this resolver should be used with caution. MA generic version of L, allowing coroutines with 3 functors embedded in other  functors. $/0123456789:;<=>?@ABCDEFGHIJKLMfghij/0123456789:;<=>?@ABCDEFGHIJKLM7856342/109:;<=>?@ABCDFHJLEGIKM/1023456789:;<=>?@ABCDEFGHIJKLMfghijNone N&Class of functors that can be lifted. OjConvert the ancestor functor into its descendant. The descendant functor typically contains the ancestor. P4Class of functors that can contain another functor. S Run a nested . that can suspend both itself and the current . T Much like ", but with two nested coroutines. ULike e, but for nested coroutines that are allowed to suspend the current coroutine as well as themselves. ] If both coroutines try to suspend the current coroutine in the same step, the left coroutine's suspension will have  precedence. VLike  V, but for nested coroutines that are allowed to suspend the current coroutine as well m as themselves. If both coroutines try to suspend the current coroutine in the same step, the left coroutine's " suspension will have precedence. W4Converts a coroutine into a child nested coroutine. X9Converts a coroutine into a descendant nested coroutine. NOPQRSTUVWXklm NOPQRSTUVWX STUVPQRNOWX NOPQRSTUVWXklmn       !"#$%&&'()*+,-./0123456778899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgheijklmnopqrstuvmonad-coroutine-0.7.1!Data.Functor.Contravariant.TickerControl.Monad.Coroutine*Control.Monad.Coroutine.SuspensionFunctorsControl.Monad.Coroutine.Nestedcontravariant-0.1.3Data.Functor.Contravariant contramap ContravariantSeesawResolver resumeLeft resumeRight resumeBoth PairBinder SomeFunctorBoth RightSomeLeftSomeNaughtCoroutineStepResult Coroutineresume composePairsuspendmapMonad mapSuspensionmapFirstSuspension runCoroutinebounce pogoStickfoldRunsequentialBinderparallelBinder liftBindercouplemergeseesaw seesawStepsTicker splitTickedtickNonetickOne tickCount tickPrefixOftickWhilePrefixOf tickWhile tickUntiltickAllandThenandor EitherFunctorRightFLeftF ParseRequestRequestAwaitYield eitherFunctoryieldawaitrequest requestParse concatYields concatAwaitsawaitYieldResolverawaitMaybeYieldResolverawaitYieldChunkResolverrequestsResolvertickerYieldResolverliftedTickerYieldResolvertickerRequestResolverliftedTickerRequestResolverlazyTickerRequestResolverliftedLazyTickerRequestResolverparserRequestResolverliftedParserRequestResolverlazyParserRequestResolvernestedLazyParserRequestResolverAncestorFunctor liftFunctor ChildFunctorParentwrappogoStickNested coupleNested seesawNestedseesawNestedSteps liftParent liftAncestortransformers-0.2.2.0Data.Functor.ComposeCompose$fFunctorSomeFunctor$fFunctorNaught$fMonadIOCoroutine$fMonadTransCoroutine$fMonadParallelCoroutine$fMonadCoroutine$fApplicativeCoroutine$fFunctorCoroutinebase Data.MaybeNothing$fContravariantTicker Data.Eithereitherincremental-parser-0.2"Text.ParserCombinators.IncrementalParser$fFunctorEitherFunctor$fFunctorParseRequest$fFunctorRequest$fFunctorAwait$fFunctorYield$fAncestorFunctorad$fAncestorFunctoraa$fChildFunctorEitherFunctor