wD_      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL 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 { | } ~   Safe-InferredThe (MonadPlusP p)7 constraint is equivalent to the following polymorphic  constraint: F (forall a' a b' b m . (Monad m) => MonadPlus (p a' a b' b m)) => ... The (ProxyInternal p)- constraint is (basically) equivalent to the & following polymorphic constraint: ! (forall a' a b' b m . (Monad m) # => Monad (p a' a b' b m) # , MonadTrans (p a' a b' b ) # , MFunctor (p a' a b' b m) # , MonadIO (p a' a b' b m)  ) => ... The core API for the pipes library  ; input from upstream, passing an argument with the request  request a' passes a'. as a parameter to upstream that upstream may 0 use to decide what response to return.   binds the upstream's  response of type a to its own return value.  2 with an output for downstream and bind downstream's next     respond b satisfies a downstream   by supplying the value b.    blocks until downstream  s a new value and binds the  argument of type b' from the next   as its return value. Connect an upstream   that handles all  s Point-ful version of () Connect a downstream   that handles all  s Point-ful version of () Pull-based composition !Compose two proxies blocked on a  !, generating a new proxy blocked  on a  6. Begins from the downstream end and satisfies every    with a  . Pull-based identity ) forwards requests followed by responses # idT = request >=> respond >=> idT Push-based composition !Compose two proxies blocked on a  !, generating a new proxy blocked  on a  4. Begins from the upstream end and satisfies every    with a   Push-based identity ) forwards responses followed by requests ' coidT = respond >=> request >=> coidT Equivalent to () with the arguments flipped Equivalent to () with the arguments flipped Equivalent to ( ) with the arguments flipped Equivalent to ( ) with the arguments flipped        Safe-Inferred%Uniform interface to lifting proxies Lift a   Kleisli arrow  mapP = (lift .)  Safe-Inferred)A monad in the category of monads, using  from  as the  analog of  and  as the analog of ():  embedP liftP = id   embedP f (liftP p) = f p  5 embed g (embed f t) = embed (\p -> embed g (f p)) t Embed a newly created  layer within an existing layer  is analogous to () ,A functor in the category of proxies, using  as the analog of  : & hoistP f . hoistP g = hoistP (f . g)   hoistP id = id Lift a proxy morphism from p1 to p2 into a proxy morphism from  (t p1) to (t p2)  Squash to  layers into a single layer  is analogous to join Proxy morphism  Safe-InferredThe  proxy transformer !Run an  'K' leisi arrow, returning either a  or  "#Abort the computation and return a  result # Synonym for  $ Synonym for " %!Resume from an aborted operation &% with the arguments flipped ' over the 'L' eft variable  !"#$%Original computation Handler Handled computation &Handler Original computation Handled computation '       !"#$%&'  !"#$%&' !"#$%&'      Safe-Inferred(The  proxy transformer +Run a ( 'K'&leisli arrow, returning the result or  ,A synonym for  -A synonym for  ()*+,- !"()*+,-()*+,-()*+,- !" Safe-Inferred .The State proxy transformer 1Run a .3 computation, producing the final result and state 2Run a . 'K'3leisli arrow, procuding the final result and state 3 Evaluate a .* computation, but discard the final state 4 Evaluate a . 'K'*leisli arrow, but discard the final state 5 Evaluate a .+ computation, but discard the final result 6 Evaluate a . 'K'+leisli arrow, but discard the final result 7Get the current state 8Set the current state 9*Modify the current state using a function :*Get the state filtered through a function ./0123456789:#$%&'()*+,-./ ./0123456789: ./0123456789:./0123456789:#$%&'()*+,-./ Safe-Inferred; The strict Writer proxy transformer < Create a ;3 from a proxy that generates a result and a monoid =Run a ;4 computation, producing the final result and monoid >Run a ; 'K'4leisli arrow, producing the final result and monoid ? Evaluate a ;+ computation, but discard the final result @ Evaluate a ; 'K'+leisli arrow, but discard the final result AAdd a value to the monoid B*Modify the result of a writer computation ;01<=>?@AB23456789:;<=>?;<=>?@AB;<=>?@AB;01<=>?@AB23456789:;<=>? Safe-Inferred C Compose a 'K'!leisli arrow with itself forever Use C: to abstract away the following common recursion pattern:   p a = do  ...  a' <- respond b  p a' Using C, you can instead write:  p = foreverK $ \a -> do  ...  respond b D Repeat a 'K'leisli arrow multiple times E#Convenience function equivalent to (lift .) ' liftK f >=> liftK g = liftK (f >=> g)   liftK return = return F#Convenience function equivalent to  (hoist f .) GLift the base monad  raise = hoist lift HLift the base monad of a 'K' leisli arrow  raiseK = hoistK lift I#Convenience function equivalent to  (hoistP f .) JLift the base proxy  raiseP = hoistP liftP KLift the base proxy of a 'K' leisli arrow  raisePK = hoistPK liftP CDEFMonad morphism Kleisli arrow GHIProxy morphism Proxy Kleisli arrow JProxy KProxy Kleisli arrow CDEFGHIJK CDEFGHIJK CDEFGHIJK  Safe-Inferred LA self-contained L, ready to be run by runProxy Ls never request or respond. MClient a' a sends requests of type a' and receives responses of  type a. Ms never respond. NServer b' b receives requests of type b' and sends responses of type  b. Ns never request. OA O' that consumes values flowing upstream Os never request. PA Q' that produces values flowing upstream Ps never respond. QA T! where everything flows upstream RA T that consumes values Rs never respond. SA T that produces values Ss never request. TA unidirectional Proxy. UThe empty type, denoting a 'C' losed end LMNOPQRSTU@ LMNOPQRSTU UTSRQPOMNL LMNOPQRSTU@  Safe-InferredVThe two generalized "ListT" categories Wf >\\ p replaces all  s in p with f. Equivalent to to () for Z Point-ful version of (c) Xp //> f replaces all  s in p with f. Equivalent to (A) for ^ Point-ful version of (d) YY is isomorphic to "ListT done right" Z A monad transformer over a proxy's upstream output ]] is isomorphic to "ListT done right" ^ A monad transformer over a proxy's downstream output a Convert a ^ 'K'leisli arrow into a proxy b Convert a Z 'K'leisli arrow into a proxy cf \>\ g replaces all  s in g with f. Equivalent to (B) for Z Point-free version of (W) df />/ g replaces all  s in f with g. Equivalent to (C) for ^ Point-free version of (X) eEquivalent to (c) with the arguments flipped fEquivalent to (d) with the arguments flipped gEquivalent to (W) with the arguments flipped hEquivalent to (X) with the arguments flipped !VWXYZ[\]^_`abcdefghDEFGHIJKLMNOPQVWXYZ[\]^_`abcdefgh^_`a]Z[\bYVWXcdefghVWXYZ[\]^_`abcdefghDEFGHIJKLMNOPQ  TrustworthyiA i: communicates with an upstream interface and a downstream  interface. The type variables of ProxyFast req_a' resp_a req_b' resp_b m r signify:  req_a'2 - The request supplied to the upstream interface  resp_a3 - The response provided by the upstream interface  req_b'4 - The request supplied by the downstream interface  resp_b5 - The response provided to the downstream interface  m  - The base monad  r  - The final return value nRun a self-sufficient i* Kleisli arrow, converting it back to the  base monad oRun a self-sufficient i( Kleisli arrow, converting it back to a $ Kleisli arrow in the base monad pRun the Pipe9 monad transformer, converting it back to the base monad q?The monad transformer laws are correct when viewed through the q  function:  0 observe (lift (return r)) = observe (return r)  : observe (lift (m >>= f)) = observe (lift m >>= lift . f) FThis correctness comes at a moderate cost to performance, so use this = function sparingly or else you would be better off using  Control.Proxy.Core.Correct. KYou do not need to use this function if you use the safe API exported from   Control.Proxy;, which does not export any functions or constructors that , can violate the monad transformer laws. R-Only satisfies monad transformer laws modulo q ijklmSTUnopqVWXYZR[\] ijklmnopq imlkjnopqimlkjSTUnopqVWXYZR[\]  Safe-InferredrThe Identity proxy transformer uWrap a 'K'leisli arrow in r vRun an P 'K' leisli arrow rstuv^_`abcdefghijklrstuvrstuvrstuv^_`abcdefghijkl  Safe-InferredwThe base functor for the { type {A {: communicates with an upstream interface and a downstream  interface. The type variables of ProxyCorrect req_a' resp_a req_b' resp_b m r  signify:  req_a'2 - The request supplied to the upstream interface  resp_a3 - The response provided by the upstream interface  req_b'4 - The request supplied by the downstream interface  resp_b5 - The response provided to the downstream interface  m  - The base monad  r  - The final return value ~Run a self-sufficient {& Kleisli arrow, converting it back to  the base monad Run a self-sufficient {( Kleisli arrow, converting it back to a $ Kleisli arrow in the base monad Run the Pipe9 monad transformer, converting it back to the base monad wxyz{|}~mnopqrstu wxyz{|}~ {|}wzyx~wzyx{|}~mnopqrstu Safe-InferredThe  Codensity proxy transformer Run a 9 proxy, converting, converting it back to the base proxy Run a  'K'3leisli arrow, converting it back to the base proxy vwxyz{|}~vwxyz{|}~ Safe-InferredThe Reader proxy transformer Run a ( computation, supplying the environment Run a  'K'(leisli arrow, supplying the environment Get the environment "Get a function of the environment Modify a computation'#s environment (a specialization of ) Modify a computation')s environment (a more general version of )   Safe-InferredA self-contained  that is ready to be run s never   nor  . Wait for input from upstream 0 blocks until input is available from upstream. Deliver output downstream 9 restores control back downstream and binds its value to . $Convert a pure function into a pipe Corresponds to (<<<)/() from Control.Category Corresponds to (>>>) from Control.Category Corresponds to  from Control.Category  Safe-InferredD(mapD f) applies f to all values going 'D' ownstream. & mapD f1 >-> mapD f2 = mapD (f2 . f1)   mapD id = idT (mapU g) applies g to all values going 'U' pstream. & mapU g1 >-> mapU g2 = mapU (g1 . g2)   mapU id = idT  (mapB f g) applies f$ to all values going downstream and g to all  values going upstream. Mnemonic: map 'B' idirectional 6 mapB f1 g1 >-> mapB f2 g2 = mapB (f2 . f1) (g1 . g2)   mapB id id = idT  (mapMD f) applies the monadic function f to all values going downstream + mapMD f1 >-> mapMD f2 = mapMD (f1 >=> f2)   mapMD return = idT  (mapMU g) applies the monadic function g to all values going upstream + mapMU g1 >-> mapMU g2 = mapMU (g2 >=> g1)   mapMU return = idT  (mapMB f g) applies the monadic function f to all values going ( downstream and the monadic function g to all values going upstream. = mapMB f1 g1 >-> mapMB f2 g2 = mapMB (f1 >=> f2) (g2 >=> g1)   mapMB return return = idT (useD f) executes the monadic function f on all values flowing  'D' ownstream 1 useD f1 >-> useD f2 = useD (\a -> f1 a >> f2 a)   useD (\_ -> return ()) = idT (useU g) executes the monadic function g on all values flowing  'U'pstream 4 useU g1 >-> useU g2 = useU (\a' -> g2 a' >> g1 a')   useU (\_ -> return ()) = idT  (useB f g) executes the monadic function f on all values flowing ( downstream and the monadic function g on all values flowing upstream O useB f1 g1 >-> useB f2 g2 = useB (\a -> f1 a >> f2 a) (\a' -> g2 a' >> g1 a')  0 useB (\_ -> return ()) (\_ -> return ()) = idT  (execD md) executes md/ every time values flow downstream through it. . execD md1 >-> execD md2 = execD (md1 >> md2)   execD (return ()) = idT  (execU mu) executes mu- every time values flow upstream through it. . execU mu1 >-> execU mu2 = execU (mu2 >> mu1)   execU (return ()) = idT  (execB md mu) executes mu- every time values flow upstream through it,  and executes md/ every time values flow downstream through it. C execB md1 mu1 >-> execB md2 mu2 = execB (md1 >> md2) (mu2 >> mu1)   execB (return ()) = idT  (takeB n) allows n upstream/&downstream roundtrips to pass through @ takeB n1 >=> takeB n2 = takeB (n1 + n2) -- n1 >= 0 && n2 >= 0   takeB 0 = return  is  with a ()( return value, convenient for composing (takeWhileD p): allows values to pass downstream so long as they satisfy  the predicate p. + -- Using the "All" monoid over functions:  mempty = \_ -> True  (p1 <> p2) a = p1 a && p2 a  9 takeWhileD p1 >-> takeWhileD p2 = takeWhileD (p1 <> p2)   takeWhileD mempty = idT (takeWhileU p)< allows values to pass upstream so long as they satisfy the  predicate p. 9 takeWhileU p1 >-> takeWhileU p2 = takeWhileU (p1 <> p2)   takeWhileD mempty = idT  (dropD n) discards n values going downstream @ dropD n1 >-> dropD n2 = dropD (n1 + n2) -- n2 >= 0 && n2 >= 0   dropD 0 = idT  (dropU n) discards n values going upstream @ dropU n1 >-> dropU n2 = dropU (n1 + n2) -- n2 >= 0 && n2 >= 0   dropU 0 = idT (dropWhileD p)9 discards values going downstream until one violates the  predicate p. + -- Using the "Any" monoid over functions:  mempty = \_ -> False  (p1 <> p2) a = p1 a || p2 a  9 dropWhileD p1 >-> dropWhileD p2 = dropWhileD (p1 <> p2)   dropWhileD mempty = idT (dropWhileU p)7 discards values going upstream until one violates the  predicate p. 9 dropWhileU p1 >-> dropWhileU p2 = dropWhileU (p1 <> p2)   dropWhileU mempty = idT  (filterD p)= discards values going downstream if they fail the predicate  p + -- Using the "All" monoid over functions:  mempty = \_ -> True  (p1 <> p2) a = p1 a && p2 a  0 filterD p1 >-> filterD p2 = filterD (p1 <> p2)   filterD mempty = idT  (filterU p); discards values going upstream if they fail the predicate p 0 filterU p1 >-> filterU p2 = filterU (p1 <> p2)   filterU mempty = idT Convert a list into a S 6 fromListS xs >=> fromListS ys = fromListS (xs ++ ys)   fromListS [] = return Convert a list into a P 6 fromListC xs >=> fromListC ys = fromListC (xs ++ ys)   fromListC [] = return S version of  P version of  S version of  P version of  ?Non-deterministically choose from all values in the given list C mappend <$> eachS xs <*> eachS ys = eachS (mappend <$> xs <*> ys)  # eachS (pure mempty) = pure mempty ?Non-deterministically choose from all values in the given list C mappend <$> eachC xs <*> eachC ys = eachC (mappend <$> xs <*> ys)  # eachC (pure mempty) = pure mempty @Non-deterministically choose from all values in the given range @Non-deterministically choose from all values in the given range Fold values flowing 'D' ownstream & foldD f >-> foldD g = foldD (f <> g)   foldD mempty = idT Fold values flowing 'U'pstream & foldU f >-> foldU g = foldU (g <> f)   foldU mempty = idT Fold that returns whether  values flowing 'D'ownstream satisfy the  predicate Fold that returns whether  values flowing 'U'pstream satisfy the  predicate Fold that returns whether  values flowing 'D'ownstream satisfy the  predicate 8 terminates on the first value that fails the predicate Fold that returns whether  values flowing 'U'pstream satisfy the  predicate 8 terminates on the first value that fails the predicate Fold that returns whether  value flowing 'D'ownstream satisfies  the predicate Fold that returns whether  value flowing 'U'pstream satisfies  the predicate Fold that returns whether  value flowing 'D'ownstream satisfies the  predicate < terminates on the first value that satisfies the predicate Fold that returns whether  value flowing 'U'pstream satisfies the  predicate < terminates on the first value that satisfies the predicate  Compute the  of all values that flow 'D' ownstream  Compute the  of all values that flow 'U'pstream  Compute the  of all values that flow 'D' ownstream  Compute the  of all values that flow 'U'pstream Count how many values flow 'D' ownstream Count how many values flow 'U'pstream Retrieve the first value going 'D' ownstream Retrieve the first value going 'D' ownstream + terminates on the first value it receives Retrieve the first value going 'U'pstream Retrieve the first value going 'U'pstream + terminates on the first value it receives Retrieve the last value going 'D' ownstream Retrieve the last value going 'U'pstream Fold the values flowing 'D'ownstream into a list Fold the values flowing 'U'pstream into a list Fold equivalent to  .To see why, consider this isomorphic type for : ) foldr :: (a -> b -> b) -> [a] -> Endo b Fold equivalent to  Left strict fold over 'D'ownstream values Left strict fold over 'U'pstream values  Lift a proxy to operate only on  values flowing 'D'ownstream and  forward  values  Lift a proxy to operate only on  values flowing 'D'ownstream and  forward  values  Lift a proxy to operate only on  values flowing 'U' pstream and  forward  values  Lift a proxy to operate only on  values flowing 'D'ownstream and  forward  values Zip values flowing downstream >Interleave values flowing downstream using simple alternation Compose 8 with a closed upstream end to create a polymorphic end Compose : with a closed downstream end to create a polymorphic end DgDD Safe-Inferred Synonym for  A S that sends lines from stdin downstream A P that sends lines from stdin upstream  input from stdin one line at a time and send 'D' ownstream  input from stdin one line at a time and send 'U'pstream  Synonym for  s all values flowing 'D' ownstream to stdout s all values flowing 'U' pstream to stdout #s all values flowing through it to stdout Prefixes upstream values with "U: " and downstream values with "D: " s all values flowing 'D' ownstream to stdout s all values flowing 'U' pstream to stdout #s all values flowing through it to stdout Prefixes upstream values with "U: " and downstream values with "D: " A S+ that sends lines from a handle downstream A P that sends lines from a Handle upstream s all values flowing 'D'ownstream to a Handle s all values flowing 'U' pstream to a Handle %s all values flowing through it to a Handle Prefixes upstream values with "U: " and downstream values with "D: " s all values flowing 'D'ownstream to a Handle s all values flowing 'U' pstream to a Handle %s all values flowing through it to a Handle Prefixes upstream values with "U: " and downstream values with "D: "  Safe-InferredCDEFGHIJK Safe-InferredBC CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghrstuv Safe-InferredBC CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghinopqrstuv Safe-Inferred Safe-Inferred  s form a 0 instance when you rearrange the type variables 2A self-contained pipeline that is ready to be run A pipe that consumes values A pipe that produces values The base type for pipes  a2 - The type of input received from upstream pipes  b4 - The type of output delivered to downstream pipes  m - The base monad  r - The type of the return value Wait for input from upstream. 0 blocks until input is available from upstream. Deliver output downstream. 7 restores control back upstream and binds its value to . $Convert a pure function into a pipe  pipe f = forever $ do  x <- await  yield (f x) Corresponds to ()/() from Control.Category Corresponds to () from Control.Category Corresponds to  from Control.Category Run the ; monad transformer, converting it back into the base monad  !"#$%&'()*+,-./01234566789:;<=>??@ABCDDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` a b c d e f g h i j k l m n o o p q r r s t u v w x y z { | } ~      }    ! ghi}~      !"#$%&'()*+,-./0P123456789:;<=>? j@AB 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 tuvwxyz{|}~ pipes-3.2.0Control.Proxy.ClassControl.Proxy.TransControl.Proxy.MorphControl.Proxy.Trans.EitherControl.Proxy.Trans.MaybeControl.Proxy.Trans.StateControl.Proxy.Trans.WriterControl.Proxy.Prelude.KleisliControl.Proxy.SynonymControl.Proxy.ListTControl.Proxy.Core.FastControl.Proxy.Trans.IdentityControl.Proxy.Core.CorrectControl.Proxy.Trans.CodensityControl.Proxy.Trans.ReaderControl.Proxy.PipeControl.Proxy.Prelude.BaseControl.Proxy.Prelude.IO Control.PipeControl.Proxy.PreludeControl.Proxy.Core Control.ProxyControl.Proxy.Tutorial MonadPlusPmzero_Pmplus_P ProxyInternalreturn_P?>=lift_Phoist_PliftIO_PProxyrequestrespond->>>>~>->idT>~>coidT<-<<~<<<-~<< ProxyTransliftPmapPPMonadembedPPFunctorhoistPsquashPEitherP runEitherP runEitherKleftrightthrowcatchhandlefmapLMaybeP runMaybeP runMaybeKnothingjustStatePunStateP runStateP runStateK evalStateP evalStateK execStateP execStateKgetputmodifygetsWriterPwriterP runWriterP runWriterK execWriterP execWriterKtellcensorforeverK replicateKliftKhoistKraiseraiseKhoistPKraisePraisePKSessionClientServer CoConsumer CoProducerCoPipeConsumerProducerPipeCListT>\\//> CoProduceTRequestT runRequestTProduceTRespondT runRespondT runRespondK runRequestK\>\/>//+>idPmapDmapUmapBmapMDmapMUmapMBuseDuseUuseBexecDexecUexecBtakeBtakeB_ takeWhileD takeWhileUdropDdropU dropWhileD dropWhileUfilterDfilterU fromListS fromListC enumFromS enumFromC enumFromToS enumFromToCeachSeachCrangeSrangeCfoldDfoldUallDallUallD_allU_anyDanyUanyD_anyU_sumDsumUproductDproductUlengthDlengthUheadDheadD_headUheadU_lastDlastUtoListDtoListUfoldrDfoldrUfoldlD'foldlU'leftDrightDleftUrightUzipDmergeDunitDunitUstdinSgetLineSgetLineCreadLnSreadLnCstdoutD putStrLnD putStrLnU putStrLnBprintDprintUprintB hGetLineS hGetLineChPrintDhPrintUhPrintB hPutStrLnD hPutStrLnU hPutStrLnBPipeCunPipeCYieldAwaitbaseGHC.Basereturn Control.Monad=<<fmap Data.EitherEitherLeftRight$fPMonadEitherP$fPFunctorEitherP$fProxyTransEitherP$fMonadPlusPEitherP$fProxyEitherP$fProxyInternalEitherP$fMonadPlusEitherP$fAlternativeEitherP$fMonadIOEitherP$fMFunctorEitherP$fMonadTransEitherP$fMonadEitherP$fApplicativeEitherP$fFunctorEitherP Data.MaybeMaybeNothingmzero$fPMonadMaybeP$fPFunctorMaybeP$fProxyTransMaybeP$fMonadPlusPMaybeP $fProxyMaybeP$fProxyInternalMaybeP$fMonadPlusMaybeP$fAlternativeMaybeP$fMonadIOMaybeP$fMFunctorMaybeP$fMonadTransMaybeP $fMonadMaybeP$fApplicativeMaybeP$fFunctorMaybeP$fPFunctorStateP$fProxyTransStateP$fMonadPlusPStateP $fProxyStateP$fProxyInternalStateP$fMonadPlusStateP$fAlternativeStateP$fMonadIOStateP$fMFunctorStateP$fMonadTransStateP $fMonadStateP$fApplicativeStateP$fFunctorStateP unWriterP$fPMonadWriterP$fPFunctorWriterP$fProxyTransWriterP$fMonadPlusPWriterP$fProxyWriterP$fProxyInternalWriterP$fMonadPlusWriterP$fAlternativeWriterP$fMonadIOWriterP$fMFunctorWriterP$fMonadTransWriterP$fMonadWriterP$fApplicativeWriterP$fFunctorWriterP>>=<=<>=>$fMonadPlusRequestT$fAlternativeRequestT$fMonadIORequestT$fMonadTransRequestT$fMonadRequestT$fApplicativeRequestT$fFunctorRequestT$fMonadPlusRespondT$fAlternativeRespondT$fMonadIORespondT$fMonadTransRespondT$fMonadRespondT$fApplicativeRespondT$fFunctorRespondT$fMonadTransProxyFast_bind_req_resp$fListTProxyFast$fProxyProxyFast$fProxyInternalProxyFast$fMonadIOProxyFast$fMFunctorProxyFast$fMonadProxyFast$fApplicativeProxyFast$fFunctorProxyFast$fPMonadIdentityP$fPFunctorIdentityP$fProxyTransIdentityP$fMonadPlusPIdentityP$fListTIdentityP$fProxyIdentityP$fProxyInternalIdentityP$fMonadPlusIdentityP$fAlternativeIdentityP$fMonadIOIdentityP$fMFunctorIdentityP$fMonadTransIdentityP$fMonadIdentityP$fApplicativeIdentityP$fFunctorIdentityP$fListTProxyCorrect$fProxyProxyCorrect$fProxyInternalProxyCorrect$fMonadIOProxyCorrect$fMFunctorProxyCorrect$fMonadTransProxyCorrect$fMonadProxyCorrect$fApplicativeProxyCorrect$fFunctorProxyCorrect unCodensityP$fPFunctorCodensityP$fProxyTransCodensityP$fListTCodensityP$fProxyCodensityP$fMonadPlusPCodensityP$fProxyInternalCodensityP$fMonadPlusCodensityP$fAlternativeCodensityP$fMonadIOCodensityP$fMFunctorCodensityP$fMonadTransCodensityP$fMonadCodensityP$fApplicativeCodensityP$fFunctorCodensityP$fPMonadReaderP$fPFunctorReaderP$fProxyTransReaderP$fMonadPlusPReaderP$fListTReaderP$fProxyReaderP$fProxyInternalReaderP$fMonadPlusReaderP$fAlternativeReaderP$fMonadIOReaderP$fMFunctorReaderP$fMonadTransReaderP$fMonadReaderP$fApplicativeReaderP$fFunctorReaderP.idGHC.EnumenumFrom enumFromTo Data.MonoidAllAnySumProductfoldrMonoidappEndoEndogetAllgetAnygetSum getProductgetFirstFirstgetLastLasttransformers-0.3.0.0Control.Monad.Trans.Writer.Lazy execWriterT execWriter runWriter runWriterTWriterT Control.Monad.Trans.State.Strict execStateT evalStateT execState evalStaterunState runStateTStateT Text.Readread System.IOputStrLnprintforever mmorph-1.0.0Control.Monad.MorphhoistMFunctorControl.Monad.Trans.Class MonadTransliftControl.CategoryCategory<<<>>>$fCategoryPipeC$fMonadTransPipe $fMonadPipe$fApplicativePipe $fFunctorPipe