úÎ2Íz      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy  Safe-InferedKIn 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 z instance. I Some sinks will consume all available data and only produce a result at  the "end" of a data stream (e.g., sum). ENote that you can indicate any leftover data from processing via the Maybe  input field of the Done0 constructor. However, it is a violation of the  SinkE invariants to return leftover data when no input has been consumed. = Concrete, that means that a function like yield is invalid:  # yield :: input -> Sink input m () $ yield input = Done (Just input) () A SinkB should clean up any resources it has allocated when it returns a  value.  Since 0.3.0 )Perform some monadic action to continue. Processing complete. Awaiting more input.  Closing a Sink returns the final output.  Since 0.3.0 Push a value into a Sink and get a new Sink as a result.  Since 0.3.0  {|}~€    {|}~€ 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.3.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.3.0  Construct a 7 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.3.0  Construct a 3. Note that your push and close functions need not ! explicitly perform any cleanup.  Since 0.3.0 Transform the monad a  lives in. See  transSource for more information.  Since 0.3.0 Close a Sink9 if it is still open, discarding any output it produces.  Since 0.3.0 initial state push AClose. Note that the state is not returned, as it is not needed.  resource and/or state allocation  resource and/or state cleanup push close    Safe-InferedA Source9 has two operations on it: pull some data, and close the  Source. A Source7 should free any resources it allocated when either it  returns Closed7 or when it is explicitly closed (the second record on  either the Open or SourceM constructors).  Since 0.3.0 /Requires a monadic action to retrieve the next Source6 in the stream. Second record allows you to close the Source. A Source# which has no more data available. A Source4 providing more data. Provides records for the next Source7 in the stream, a close action, and the data provided. ‚‚  Safe-InferedA Conduit= allows data to be pushed to it, and for each new input, can I produce a stream of output values (possibly an empty stream). It can be  considered a hybrid of a Sink and a Source. A ConduitA has four constructors, corresponding to four distinct states of  operation.  Since 0.3.0 DIndicates that a monadic action must be taken to determine the next  Conduit/. It also provides an early close action. Like  HaveOutput,  this action returns (),, since it should only be used when no more  output is requested. EIndicates that no more output is available, and no more input may be D sent. It provides an optional leftover input record. Note: It is a  violation of Conduit'0s invariants to return leftover output that was 0 never consumed, similar to the invariants of a Sink. Indicates that the Conduit) has more output available. It has three  records: the next Conduit, to continue the stream, a close action for J early termination, and the output currently available. Note that, unlike   NeedInput , the close action here returns () instead of Source. The  reasoning is that  HaveOutput& will only be closed early if no more 2 output is requested, since no input is required. Indicates that the Conduit& needs more input in order to produce 1 output. It also provides an action to close the Conduit early, for H cases when there is no more input available, or when no more output is , requested. Closing at this point returns a Source to allow for either ' consuming or ignoring the new stream. When closing a Conduit+, it can produce a final stream of values.  Since 0.3.0 !Pushing new data to a Conduit produces a new Conduit.  Since 0.3.0  !ƒ ! !ƒ  Safe-Infered"%The return value when pulling in the sourceIO function. Either indicates " no more data, or the next value.  Since 0.3.0 %%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.3.0 ( Construct a 7 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.3.0 ) Construct a # based on some IO actions for alloc/ release.  Since 0.3.0 *A combination of ) and (.  Since 0.3.0 +Transform the monad a  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.3.0 ,Close a Source#, regardless of its current state.  Since 0.3.0 "#$%&'(Initial state Pull function ) resource and/or state allocation  resource and/or state cleanup >Pull function. Note that this should not perform any cleanup. * resource and/or state allocation  resource and/or state cleanup GPull function. Note that this need not explicitly perform any cleanup. +, "#$%&'()*+,"$#%'&()*+, None„…†„…†„…†  Safe-Infered-Helper 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.3.0 .Return value from a -.  Since 0.3.0 /Pass control to a new conduit. 0End the conduit. 1+Set a new state, and emit some new output. 2A 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.3.0 5A 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.3.0 88A helper function for returning a list of values from a Conduit.  Since 0.3.0 9 Construct a 7 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.3.0 : Construct a .  Since 0.3.0 ;Transform the monad a  lives in. See  transSource for more information.  Since 0.3.0 < Convert a - into a .  Since 0.3.0 =Specialised version of < 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.3.0 >Close a Conduit early, discarding any output.  Since 0.3.0 -./012345678 The next Conduit. to return after the list has been exhausted. &A close action for early termination. $The values to send down the stream. 9initial state Push function. QClose function. The state need not be returned, since it will not be used again. : 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. ;<initial state =>‡ˆ-./0123456789:;<=> -.10/24357689:;<=>‡ˆ Safe-Infered ?2Provide 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.3.0 BWhen 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.3.0 C/A typeclass allowing us to unify operators for  and  B.  Since 0.3.0 DKThe connect operator, which pulls data from a source and pushes to a sink. 0 There are two ways this process can terminate:   If the Sink is a Done constructor, the Source is closed.  If the Source is a Closed constructor, the Sink is closed. +This function will automatically close any Sources, but will not close any  BufferedSource;s, allowing them to be reused. Also, leftover data will be  discarded when connecting a Source$, but will be buffered when using a  BufferedSource.  Since 0.3.0 EHLeft fuse, combining a source and a conduit together into a new source. Any Source1 passed in will be automatically closed, while a  BufferedSource; will be left open. Leftover input will be discarded for a  Source, and buffered for a BufferedSource.  Since 0.3.0 FERight fuse, combining a conduit and a sink together into a new sink. #Any leftover data returns from the Sink will be discarded.  Since 0.3.0 GAMiddle fuse, combining two conduits together into a new conduit. $Any leftovers provided by the inner Conduit will be discarded.  Since 0.3.0 HPlaces the given Source1 and a buffer into a mutable variable. Note that  you should manually call J when the B is no  longer in use.  Since 0.3.0 ITurn a B into a !. Note that in general this will  mean your original B# 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.3.0 JClose the underlying  for the given B. Note J that this function can safely be called multiple times, as it will first  check if the  was previously closed.  Since 0.3.0 ?@ABCDEFGHIJ‰Š‹K  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKBHIJC  ! DEFG(*%'&)"$#+, 89576:243;>-<=.10/?A@ ?A@BCDEFGHIJ‰Š‹ Safe-InferedKA strict left fold.  Since 0.3.0 LA monadic strict left fold.  Since 0.3.0 M.Apply the action to all values in the stream.  Since 0.3.0 NConvert a list into a source.  Since 0.3.0 OBIgnore 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.3.0 PFTake 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.3.0 Q3Take a single value from the stream, if available.  Since 0.3.0 RKLook at the next value in the stream, if available. This function will not ! change the state of the stream.  Since 0.3.0 S2Apply a transformation to all values in a stream.  Since 0.3.0 T: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 M.  Since 0.3.0 UKApply a transformation to all values in a stream, concatenating the output  values.  Since 0.3.0 VHApply a monadic transformation to all values in a stream, concatenating  the output values.  Since 0.3.0 WU with an accumulator.  Since 0.3.0 XV with an accumulator.  Since 0.3.0 YHConsume 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.3.0 Z2Grouping input according to an equality function.  Since 0.3.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.3.0 \:Keep only values in the stream passing a given predicate.  Since 0.3.0 ]GIgnore the remainder of values in the source. Particularly useful when  combined with [.  Since 0.3.0 ^HA source that returns nothing. Note that this is just a type-restricted  synonym for Œ.  Since 0.3.0 _ECombines two sources. The new source will stop producing once either  source has been exhausted.  Since 0.3.0 KLMNOPQRSTUVWXYZ[\]^_KLMNOPQRSTUVWXYZ[\]^_N^KPOQ_RY]LMSUWZ[\TVXKLMNOPQRSTUVWXYZ[\]^_ 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.3.0 a.Stream the contents of a file as binary data.  Since 0.3.0 bStream 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.3.0 cAn alternative to b.  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.3.0 d&Stream all incoming data to the given . Note that this function  will not automatically close the Handle when processing completes.  Since 0.3.0 eAn alternative to d.  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.3.0 fFStream 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.3.0 g,Stream all incoming data to the given file.  Since 0.3.0 hGStream 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.3.0 iJEnsure 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.3.0 j4Return the next byte from the stream, if available.  Since 0.3.0 k-Return all bytes while the predicate returns True.  Since 0.3.0 l-Ignore all bytes while the predicate returns True.  Since 0.3.0 m.Take the given number of bytes, if available.  Since 0.3.0 nGSplit the input bytes into lines. In other words, split on the LF byte % (10), and strip it from the output.  Since 0.3.0 `abcdefOffset Maximum count ghijklmn`abcdefghijklmnabcfgdehi`jklmn`abcdefghijklmn Safe-Infered oA specific character encoding.  Since 0.3.0 pCConvert 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.3.0 qCConvert 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.3.0 r Since 0.3.0 s Since 0.3.0 t Since 0.3.0 u Since 0.3.0 v Since 0.3.0 w Since 0.3.0 x Since 0.3.0 opqrstuvwxŽ opqrstuvwx opqrstuvwx opqrstuvwxŽ Safe-Inferedy Use lazy I/!O to consume all elements from a Source. This function relies on ( to determine if the underlying monadic  state has been closed.  Since 0.3.0 yyyy‘        !"#$%&'() * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L MNNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvi_wx^yz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ  ‘ ’ “ ” •–—˜…™š…›œž Ÿ  conduit-0.3.0 Data.ConduitData.Conduit.ListData.Conduit.BinaryData.Conduit.TextData.Conduit.LazyData.Conduit.Types.SinkData.Conduit.Util.SinkData.Conduit.Types.SourceData.Conduit.Types.ConduitData.Conduit.Util.SourceSystem.PosixFileData.Conduit.Util.Conduitresourcet-0.3.0Control.Monad.Trans.Resource runResourceT ResourceT MonadResource monadThrow MonadThrow unsafeLiftIO MonadUnsafeIOSinkSinkMDone Processing SinkCloseSinkPush SinkIOResult IOProcessingIODoneSinkStateResultStateProcessing StateDone sinkStatesinkIO transSink sinkCloseSourceSourceMClosedOpenConduitConduitMFinished HaveOutput NeedInput ConduitClose ConduitPushSourceIOResultIOClosedIOOpenSourceStateResult StateClosed StateOpen sourceStatesourceIO sourceStateIO transSource sourceClose SequencedSinkSequencedSinkResponse StartConduitStopEmitConduitIOResult IOProducing IOFinishedConduitStateResultStateProducing StateFinishedhaveMore conduitState conduitIO transConduit sequenceSinksequence conduitCloseFlushChunkBufferedSourceIsSource$$$==$=$= bufferSourceunbufferSource bsourceClosefoldfoldMmapM_ sourceListdroptakeheadpeekmapmapM concatMap concatMapMconcatMapAccumconcatMapAccumMconsumegroupByisolatefiltersinkNull sourceNullzipopenFile sourceFile sourceHandlesourceIOHandle sinkHandle sinkIOHandlesourceFileRangesinkFile conduitFile takeWhile dropWhilelinesCodecencodedecodeutf8utf16_leutf16_beutf32_leutf32_beascii iso8859_1 lazyConsumebaseGHC.BaseMonad $fMonadIOSink$fMonadTransSink$fMonadBasebaseSink $fMonadSink$fApplicativeSink $fFunctorSink$fMonoidSource$fFunctorSource$fFunctorConduitcloseopenReadread$fFunctorConduitIOResult$fFunctorConduitStateResult$fFunctorFlush$fIsSourceBufferedSourcem$fIsSourceSourcem Data.MonoidmemptyGHC.IO.Handle.TypesHandle$fExceptionTextException $fShowCodec monadActive