śĪBū6÷”      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ   Safe-InferedA ? which can throw exceptions. Note that this does not work in a  vanilla ST$ monad. Instead, you should use the  transformer on  top of ST. 8The express purpose of this transformer is to allow the ” monad to  catch exceptions via the  typeclass. IThe Resource transformer. This transformer keeps track of all registered ( actions, and calls them upon exit (via #). Actions may be  registered via !/, or resources may be allocated atomically via   or  +. The with functions correspond closely to bracket. /Releasing may be performed before exit via the " function. This is a N highly recommended optimization, as it will ensure that scarce resources are  freed early. Note that calling release% will deregister the action, so that 1 a release action will only ever be called once. FA lookup key for a specific release action. This value is returned by  !,  and  , and is passed to ". A  which can safely run ¢ calls. A helper class for  ', stating that the base monad provides IO  actions. A 2 based on some monad which allows running of some ¢ , actions, via unsafe calls. This applies to ¢ and ”, for instance. A £A with a base that has mutable references, and allows some way to ) run base actions and clean up properly. AThe base monad for the current monad stack. This will usually be IO  or ST. Run some action in the Base% monad. This function corresponds to  ¤:, but due to various type issues, we need to have our own  version here. EGuarantee that some initialization and cleanup code is called before J and after some action. Note that the initialization and cleanup lives in 5 the base monad, while the body is in the top monad. KA base monad which provides mutable references and some exception-safe way L of interacting with them. For monads which cannot handle exceptions (e.g.,  ”G), exceptions may be ignored. However, in such cases, scarce resources  should not; be allocated in those monads, as exceptions may cause the  cleanup functions to not run. The instance for ¢$, however, is fully exception-safe. Minimal complete definition: Ref, newRef', readRef' and writeRef'. 3For monads supporting multi-threaded access (e.g., IO), this much be  an atomic modification. Create a new reference. Read a value from a reference. Write a value to a reference. FPerform some allocation, and automatically register a cleanup action. If you are performing an IO- action, it will likely be easier to use the   - function, which handles types more cleanly. Same as , but explicitly uses IO as a base. !ERegister some action that will be called precisely once, either when  # is called, or when the   is passed to ". "HCall a release action early, and deregister it from the list of cleanup  actions to be performed. # Unwrap a 7 transformer, and call all registered release actions. ;Note that there is some reference counting involved due to &. L If multiple threads are sharing the same collection of resources, only the  last call to  runResourceT will deallocate the resources. $Transform the monad a  ResourceT& lives in. This is most often used to 9 strip or add new transformers to a stack, e.g. to run a ReaderT . Note that 4 the original and new monad must both have the same  monad. %Same as , but immediately „ any exception returned. &HIntroduce a reference-counting scheme to allow a resource context to be G shared by multiple threads. Once the last thread exits, all remaining  resources will be released. HNote that abuse of this function will greatly delay the deallocation of I registered resources. This function should be used with care. A general  guideline: LIf you are allocating a resource that should be shared by multiple threads, N and will be held for a long time, you should allocate it at the beginning of  a new  ResourceT block and then call resourceForkIO from there. 'Determine if the current  ResourceT$ is still active. This is necessary  for such cases as lazy I/3O, where an unevaluated thunk may still refer to a  closed  ResourceT. T init cleanup body  allocate free resource  allocate free resource !"#$%&'¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃ(  !"#$%&'( # !"&$%  'B   !"#$%&'¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃ Safe-Infered(IA conduit has two operations: it can receive new input (a push), and can  be closed.  Since 0.2.0 ,When data is pushed to a Conduit$, it may either indicate that it is J still producing output and provide some, or indicate that it is finished M producing output, in which case it returns optional leftover input and some  final output. The  Producing constructor provides a new Conduit to be used in place of  the previous one.  Since 0.2.0 /The value of the  conduitClose record. 0The value of the  conduitPush record. ()*+,-./0ŅÓ ()*+,-./0()*+,.-/0ŅÓ Safe-Infered1KIn general, a sink will consume data and eventually produce an output when  it has consumed "enough"0 data. There are two caveats to that statement: K Some sinks do not actually require any data to produce an output. This is . included with a sink in order to allow for a £ instance. I Some sinks will consume all available data and only produce a result at  the "end" of a data stream (e.g., sum). +To allow for the first caveat, we have the 6 constructor. For the  second, the 35 constructor has two records: one for receiving more M input, and the other to indicate the end of a stream. Note that, at the end 5 of a stream, some output is required. If a specific 1 implementation M cannot always produce output, this should be indicated in its return value,  using something like a Ō or Õ. A SinkB should clean up any resources it has allocated when it returns a  value, whether that be via sinkPush or  sinkClose.  Since 0.2.0 2@This constructor is provided to allow us to create an efficient   MonadTrans instance. 7A Sink= ultimately returns a single output value. Each time data is  pushed to it, a Sink3 may indicate that it is still processing data, or L that it is done, in which case it returns some optional leftover input and  an output value. The  Processing; constructors provides updated push and close functions to " be used in place of the original Sink.  Since 0.2.0 :The value of the  sinkClose record. ;The value of the sinkPush record. 123456789:;Ö×ŲŁŚŪÜ 123456789:; 163245798:;Ö×ŲŁŚŪÜ  Safe-Infered<A helper type for sinkIO/, indicating the result of being pushed to. It > can either indicate that processing is done, or to continue.  Since 0.2.0 ?A helper type for  sinkState,, indicating the result of being pushed to. I It can either indicate that processing is done, or to continue with the  updated state.  Since 0.2.0 B Construct a 17 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.2.0 C Construct a 13. Note that your push and close functions need not ! explicitly perform any cleanup.  Since 0.2.0 DTransform the monad a 1 lives in. See  transSource for more information.  Since 0.2.0 <=>?@ABinitial state push AClose. Note that the state is not returned, as it is not needed. C resource and/or state allocation  resource and/or state cleanup push close D <=>?@ABCD<>=?A@BCD  Safe-Infered EHelper type for constructing a Conduit based on Sinks. This allows you J to write higher-level code that takes advantage of existing conduits and  sinks, and leverages a sink's monadic interface.  Since 0.2.0 FReturn value from a E.  Since 0.2.0 GPass control to a new conduit. HEnd the conduit. I+Set a new state, and emit some new output. JA helper type for  conduitIO,, indicating the result of being pushed to. A It can either indicate that processing is done, or to continue.  Since 0.2.0 MA helper type for  conduitState(, indicating the result of being pushed N to. It can either indicate that processing is done, or to continue with the  updated state.  Since 0.2.0 P Construct a (7 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.2.0 Q Construct a (.  Since 0.2.0 RTransform the monad a ( lives in. See  transSource for more information.  Since 0.2.0 S Convert a E into a (.  Since 0.2.0 TSpecialised version of S ENote that this function will return an infinite stream if provided a   SinkNoData. constructor. In other words, you probably don' t want to do  sequence . return.  Since 0.2.1 EFGHIJKLMNOPinitial state Push function. QClose function. The state need not be returned, since it will not be used again. Q resource and/or state allocation  resource and/or state cleanup GPush function. Note that this need not explicitly perform any cleanup. HClose function. Note that this need not explicitly perform any cleanup. RSinitial state TŻŽEFGHIJKLMNOPQRST EFIHGJLKMONPQRSTŻŽ  Safe-InferedUA Source9 has two operations on it: pull some data, and close the  Source. Since Source is built on top of , all acquired > resources should be automatically released anyway. Closing a Source early I is merely an optimization to free scarce resources as soon as possible. A Source7 is should free any resources it allocated when either   sourceClose is called or a Closed$ is returned. However, based on the  usage of  ResourceT", this is simply an optimization.  Since 0.2.0 Y=Result of pulling from a source. Either a new piece of data (Open), or " indicates that the source is now Closed. The Open8 constructor returns both a new value, as well as a new Source, / which should be used in place of the previous Source.  Since 0.2.0 UVWXYZ[ßąįUVWXYZ[UVWXY[Zßąį  Safe-Infered\%The return value when pulling in the sourceIO function. Either indicates " no more data, or the next value. _%The return value when pulling in the  sourceState function. Either A indicates no more data, or the next value and an updated state.  Since 0.2.0 b Construct a U7 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.2.0 c Construct a U# based on some IO actions for alloc/ release.  Since 0.2.0 dA combination of c and b.  Since 0.2.1 eTransform the monad a U lives in. Note that this will not0 thread the individual monads together, meaning J side effects will be lost. This function is most useful for transformers @ only providing context and not producing side-effects, such as ReaderT.  Since 0.2.0 \]^_`abInitial state Pull function c resource and/or state allocation  resource and/or state cleanup GPull function. Note that this need not explicitly perform any cleanup. d resource and/or state allocation  resource and/or state cleanup GPull function. Note that this need not explicitly perform any cleanup. e \]^_`abcde\^]_a`bcde Noneāćäāćäāćä Safe-Infered f2Provide for a stream of data that can be flushed.  A number of Conduit5s (e.g., zlib compression) need the ability to flush N the stream at some point. This provides a single wrapper datatype to be used  in all such circumstances.  Since 0.2.0 iWhen actually interacting with Source#s, we sometimes want to be able to K buffer the output, in case any intermediate steps return leftover data. A  BufferedSource allows for such buffering. A BufferedSource , unlike a Source", is resumable, meaning it can be  passed to multiple Sink#s without restarting. Therefore, a BufferedSource H relaxes the main invariant of this package: the same value may be used  multiple times. The intention of a BufferedSource is to be used internally by an M application or library, not to be part of its user-facing API. For example,  the Warp webserver uses a BufferedSource internally for parsing the + request headers, but then passes a normal Source to the web application  for reading the request body. IOne caveat: while the types will allow you to use the buffered source in 2 multiple threads, there is no guarantee that all BufferedSources will  handle this correctly.  Since 0.2.0 j/A typeclass allowing us to unify operators for U and  i.  Since 0.2.0 kKThe connect operator, which pulls data from a source and pushes to a sink. 2 There are three ways this process can terminate:   In the case of a  SinkNoData* constructor, the source is not opened at 4 all, and the output value is returned immediately.  The sink returns Done. If the input was a BufferedSource, any 3 leftover input is put in the buffer. For a normal Source, the leftover / value is discarded, and the source is closed.  The source return Closed$, in which case the sink is closed. 5Note that this function will automatically close any Sources, but will not  close any BufferedSources, allowing them to be reused.  Since 0.2.0 lHLeft fuse, combining a source and a conduit together into a new source. Note that any Source1 passed in will be automatically closed, while a  BufferedSource will be left open.  Since 0.2.0 mERight fuse, combining a conduit and a sink together into a new sink.  Since 0.2.0 nAMiddle fuse, combining two conduits together into a new conduit.  Since 0.2.0 oPlaces the given Source1 and a buffer into a mutable variable. Note that  you should manually call q when the i is no  longer in use.  Since 0.2.0 pTurn a i into a U!. Note that in general this will  mean your original i# will be closed. Additionally, all * leftover data from usage of the returned Source will be discarded. In , other words: this is a no-going-back move. Note:  bufferSource . unbufferSource is not the identity function.  Since 0.2.0 qClose the underlying U for the given i. Note J that this function can safely be called multiple times, as it will first  check if the U was previously closed.  Since 0.2.0 fghijklmnopqåęēT #()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqTY[ZUVWXiopqj798163245;:,.-()*+0/klmnbd_a`c\^]eB?A@C<>=DPMONQJLKRESTFIHGfhg # fhgijklmnopqåęē Safe-InferedrA strict left fold.  Since 0.2.0 sA monadic strict left fold.  Since 0.2.0 t.Apply the action to all values in the stream.  Since 0.2.0 uConvert a list into a source.  Since 0.2.0 vBIgnore a certain number of values in the stream. This function is  semantically equivalent to:   drop i = take i >> return ()  However, drop9 is more efficient as it does not need to hold values in  memory.  Since 0.2.0 wFTake some values from the stream and return as a list. If you want to ? instead create a conduit that pipes data to another sink, see ‚. . This function is semantically equivalent to:   take i = isolate i =$ consume  Since 0.2.0 x3Take a single value from the stream, if available.  Since 0.2.0 yKLook at the next value in the stream, if available. This function will not ! change the state of the stream.  Since 0.2.0 z2Apply a transformation to all values in a stream.  Since 0.2.0 {:Apply a monadic transformation to all values in a stream. MIf you do not need the transformed values, and instead just want the monadic ) side-effects of running the action, see t.  Since 0.2.0 |KApply a transformation to all values in a stream, concatenating the output  values.  Since 0.2.0 }HApply a monadic transformation to all values in a stream, concatenating  the output values.  Since 0.2.0 ~| with an accumulator.  Since 0.2.0 } with an accumulator.  Since 0.2.0 €HConsume all values from the stream and return as a list. Note that this ; will pull all values into memory. For a lazy variant, see  Data.Conduit.Lazy.  Since 0.2.0 2Grouping input according to an equality function.  Since 0.2.0 ‚EEnsure that the inner sink consumes no more than the given number of  values. Note this this does not, ensure that the sink consumes all of those 2 values. To get the latter behavior, combine with „, e.g.:   src $$ do  x <- isolate count =$ do  x <- someSink  sinkNull  return x  someOtherSink  ...  Since 0.2.0 ƒ:Keep only values in the stream passing a given predicate.  Since 0.2.0 „GIgnore the remainder of values in the source. Particularly useful when  combined with ‚.  Since 0.2.0 …HA source that returns nothing. Note that this is just a type-restricted  synonym for č.  Since 0.2.0 †ECombines two sources. The new source will stop producing once either  source has been exhausted.  Since 0.2.2 rstuvwxyz{|}~€‚ƒ„…†rstuvwxyz{|}~€‚ƒ„…†u…rwvx†y€„stz|~‚ƒ{}rstuvwxyz{|}~€‚ƒ„…† Safe-Infered‡ Open a file é/ safely by automatically registering a release  action. #While you are not required to call hClose on the resulting handle, you = should do so as early as possible to free scarce resources.  Since 0.2.0 ˆ.Stream the contents of a file as binary data.  Since 0.2.0 ‰Stream the contents of a é as binary data. Note that this  function will not automatically close the Handle when processing ) completes, since it did not acquire the Handle in the first place.  Since 0.2.0 ŠAn alternative to ‰.  Instead of taking a pre-opened é , it takes an action that opens  a é9 (in read mode), so that it can open it only when needed # and close it as soon as possible.  Since 0.2.0 ‹&Stream all incoming data to the given é. Note that this function  will not automatically close the Handle when processing completes.  Since 0.2.0 ŒAn alternative to ‹.  Instead of taking a pre-opened é , it takes an action that opens  a é: (in write mode), so that it can open it only when needed # and close it as soon as possible.  Since 0.2.0 FStream the contents of a file as binary data, starting from a certain < offset and only consuming up to a certain number of bytes.  Since 0.2.0 Ž,Stream all incoming data to the given file.  Since 0.2.0 GStream the contents of the input to a file, and also send it along the 2 pipeline. Similar in concept to the Unix command tee.  Since 0.2.0 JEnsure that only up to the given number of bytes are consume by the inner  sink. Note that this does not, ensure that all of those bytes are in fact  consumed.  Since 0.2.0 ‘4Return the next byte from the stream, if available.  Since 0.2.0 ’-Return all bytes while the predicate returns True.  Since 0.2.0 “-Ignore all bytes while the predicate returns True.  Since 0.2.0 ”.Take the given number of bytes, if available.  Since 0.2.0 •GSplit the input bytes into lines. In other words, split on the LF byte % (10), and strip it from the output.  Since 0.2.0 ‡ˆ‰Š‹ŒOffset Maximum count Ž‘’“”•‡ˆ‰Š‹ŒŽ‘’“”•ˆ‰ŠŽ‹Œ‡‘’“”•‡ˆ‰Š‹ŒŽ‘’“”• Safe-Infered –A specific character encoding.  Since 0.2.0 —CConvert text into bytes, using the provided codec. If the codec is N not capable of representing an input character, an exception will be thrown.  Since 0.2.0 ˜CConvert bytes into text, using the provided codec. If the codec is N not capable of decoding an input byte sequence, an exception will be thrown.  Since 0.2.0 ™ Since 0.2.0 š Since 0.2.0 › Since 0.2.0 œ Since 0.2.0  Since 0.2.0 ž Since 0.2.0 Ÿ Since 0.2.0 –—˜™š›œžŸźė –—˜™š›œžŸ –—˜™š›œžŸ –—˜™š›œžŸźė Safe-Infered  Use lazy I/!O to consume all elements from a Source.  Since 0.2.0     ģ !"#$%&'()*+,-./01234456789:;<=>?@ABCDEF 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 oppqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜‹™š€›œžŸ ”¢£¤„¦§Ø©Ŗ«¬§­®Æ°±§²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąį§āć§äåęēčéźėģ ķ ī ļ š ń ņ ó ōõö÷§ųł§śūüżž conduit-0.2.2Control.Monad.Trans.Resource Data.ConduitData.Conduit.ListData.Conduit.BinaryData.Conduit.TextData.Conduit.LazyData.Conduit.Types.ConduitData.Conduit.Types.SinkData.Conduit.Util.SinkData.Conduit.Util.ConduitData.Conduit.Types.SourceData.Conduit.Util.SourceSystem.PosixFile ResourceThrow resourceThrow ExceptionT runExceptionT InvalidAccess functionName ResourceT ReleaseKey ResourceIOResourceBaseIOsafeFromIOBaseResourceUnsafeIO unsafeFromIOResourceBaseresourceLiftBaseresourceBracket_HasRefRefnewRef'readRef' writeRef'atomicModifyRef'maskmask_trynewRefreadRefwriteRefwithwithIOregisterrelease runResourceTtransResourceTrunExceptionT_resourceForkIOresourceActiveConduit conduitPush conduitClose ConduitResultFinished Producing ConduitClose ConduitPushSinkSinkLiftSinkDatasinkPush sinkClose SinkNoData SinkResultDone Processing SinkCloseSinkPush SinkIOResult IOProcessingIODoneSinkStateResultStateProcessing StateDone sinkStatesinkIO transSink SequencedSinkSequencedSinkResponse StartConduitStopEmitConduitIOResult IOProducing IOFinishedConduitStateResultStateProducing StateFinished conduitState conduitIO transConduit sequenceSinksequenceSource sourcePull sourceClose SourceResultClosedOpenSourceIOResultIOClosedIOOpenSourceStateResult StateClosed StateOpen sourceStatesourceIO sourceStateIO transSourceFlushChunkBufferedSourceIsSource$$$==$=$= bufferSourceunbufferSource bsourceClosefoldfoldMmapM_ sourceListdroptakeheadpeekmapmapM concatMap concatMapMconcatMapAccumconcatMapAccumMconsumegroupByisolatefiltersinkNull sourceNullzipopenFile sourceFile sourceHandlesourceIOHandle sinkHandle sinkIOHandlesourceFileRangesinkFile conduitFile takeWhile dropWhilelinesCodecencodedecodeutf8utf16_leutf16_beutf32_leutf32_beascii iso8859_1 lazyConsumebaseGHC.STSTghc-prim GHC.TypesIOGHC.BaseMonadtransformers-base-0.4.1Control.Monad.BaseliftBase GHC.Exceptionthrow$fResourceThrowWriterT$fResourceThrowStateT$fResourceThrowRWST$fResourceThrowRWST0$fResourceThrowWriterT0$fResourceThrowStateT0$fResourceThrowReaderT$fResourceThrowErrorT$fResourceThrowMaybeT$fResourceThrowListT$fResourceThrowIdentityT$fResourceThrowIO$fResourceThrowExceptionT$fMonadBaseControlbExceptionT$fMonadTransControlExceptionT$fMonadTransExceptionT$fMonadBasebExceptionT$fMonadExceptionT$fApplicativeExceptionT$fFunctorExceptionT$fMonadBaseControlbResourceT$fMonadBasebResourceT$fMonadIOResourceT$fMonadTransResourceT$fMonadResourceT$fApplicativeResourceT$fFunctorResourceT$fExceptionInvalidAccess$fShowInvalidAccess$fTypeable1ResourceT $fResourceIOt$fResourceIOIO$fResourceBaseIOIO$fResourceUnsafeIOt$fResourceUnsafeIOST$fResourceUnsafeIOST0$fResourceUnsafeIOIO $fResourcet $fResourceST $fResourceST0 $fResourceIO $fHasRefST $fHasRefST0 $fHasRefIO$fFunctorConduit$fFunctorConduitResult Data.MaybeMaybe Data.EitherEither $fMonadIOSink$fMonadTransSink$fMonadBasebaseSink $fMonadSink$fApplicativeSink $fFunctorSink$fFunctorSinkResult$fFunctorConduitIOResult$fFunctorConduitStateResult$fMonoidSource$fFunctorSource$fFunctorSourceResultcloseopenReadread$fFunctorFlush$fIsSourceBufferedSource$fIsSourceSource Data.MonoidmemptyGHC.IO.Handle.TypesHandle$fExceptionTextException $fShowCodec