8b-נ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None None)A Source4 which has been started, but has not yet completed. 1This type contains both the current state of the Source, and the finalizer  to be run to close it.  Since 0.5.0 >Generalized conduit with leftovers returning upstream result.  Since 0.5.0 AGeneralized conduit without leftovers returning upstream result.  Since 0.5.0 $Generalized conduit with leftovers.  Since 0.5.0 'Generalized conduit without leftovers.  Since 0.5.0 JConsumes a stream of input values and produces a stream of output values, # without producing a final result.  Since 0.5.0  Generalized + with leftovers returning upstream result.  Since 0.5.0  Generalized . without leftovers returning upstream result.  Since 0.5.0  Generalized  with leftovers.  Since 0.5.0  Generalized  without leftovers.  Since 0.5.0 GConsumes a stream of input values and produces a final result, without  producing any output.  Since 0.5.0  Generalized .  Since 0.5.0 CProvides a stream of output values, without consuming any input or  producing a final result.  Since 0.5.0 GThe underlying datatype for all the types in this package. In has six  type parameters:  l7 is the type of values that may be left over from this Pipe. A Pipe  with no leftovers would use Void( here, and one with leftovers would use  the same type as the i4 parameter. Leftovers are automatically provided to  the next Pipe in the monadic chain.  i is the type of values for this Pipe's input stream.  o is the type of values for this Pipe's output stream.  u& is the result type from the upstream Pipe.  m is the underlying monad.  r is the result type.  A basic intuition is that every Pipe$ produces a stream of output values  (oH), and eventually indicates that this stream is terminated by sending a  result (r). On the receiving end of a Pipe, these become the i and u  parameters.  Since 0.5.0 FReturn leftover input, which should be provided to future operations. 4Require running of a monadic action to get the next Pipe. Processing with this Pipe* is complete, providing the final result. DRequest more input from upstream. The first field takes a new input  value and provides a new Pipe&. The second takes an upstream result D value, which indicates that upstream is producing no more results. !EProvide new output to be sent downstream. This constructor has three  fields: the next Pipe. to be used, a finalization function, and the  output value. "KWait for a single input value from upstream, terminating immediately if no  data is available.  Since 0.5.0 #This is similar to await/, but will return the upstream result value as  Left if available.  Since 0.5.0 $0Wait for input forever, calling the given inner Pipe for each piece of . new input. Returns the upstream result type.  Since 0.5.0 %9Send a single output value downstream. If the downstream Pipe  terminates, this Pipe will terminate as well.  Since 0.5.0 & Similar to yield6, but additionally takes a finalizer to be run if the  downstream Pipe terminates.  Since 0.5.0 'IProvide a single piece of leftover input to be consumed by the next pipe ! in the current monadic binding. NoteD: it is highly encouraged to only return leftover values from input ! already consumed from upstream.  Since 0.5.0 ()Perform some allocation and run an inner Pipe. Two guarantees are given  about resource finalization:   It will be prompt5. The finalization will be run as early as possible. ' It is exception safe. Due to usage of  resourcet, the finalization will + be run in the event of any exceptions.  Since 0.5.0 )'Add some code to be run when the given Pipe cleans up.  Since 0.4.1 * The identity Pipe.  Since 0.5.0 +KCompose a left and right pipe together into a complete pipe. The left pipe < will be automatically closed when the right pipe finishes.  Since 0.5.0 ,Same as +, but automatically applies / to the right Pipe.  Since 0.5.0 - Connect a Source to a Sink+ until the latter closes. Returns both the  most recent state of the Source and the result of the Sink.  We use a ResumableSource, to keep track of the most recent finalizer  provided by the Source.  Since 0.5.0 .+Run a pipeline until processing completes.  Since 0.5.0 / Transforms a Pipe0 that provides leftovers to one which does not,  allowing it to be composed. ;This function will provide any leftover values within this Pipe to any  calls to await;. If there are more leftover values than are demanded, the  remainder are discarded.  Since 0.5.0 0Transform the monad that a Pipe lives in. FNote that the monad transforming function will be run multiple times, J resulting in unintuitive behavior in some cases. For a fuller treatment,  please see:  Hhttps://github.com/snoyberg/conduit/wiki/Dealing-with-monad-transformers  Since 0.4.0 1/Apply a function to all the output values of a Pipe. This mimics the behavior of  for a  and  in pre-0.4  days.  Since 0.4.1 2Same as 1", but use a function that returns Maybe values.  Since 0.5.0 3.Apply a function to all the input values of a Pipe.  Since 0.5.0 4Convert a list into a source.  Since 0.3.0 The equivalent of GHC.Exts.build for Pipe.  Since 0.4.2 8GReturns a tuple of the upstream and downstream results. Note that this 4 will force consumption of the entire input stream.  Since 0.5.0 9 Unwraps a ResumableSource into a Source and a finalizer. A ResumableSource represents a Source! which has already been run, and J therefore has a finalizer registered. As a result, if we want to turn it  into a regular Source3, we need to ensure that the finalizer will be run * appropriately. By appropriately, I mean: E If a new finalizer is registered, the old one should not be called. < * If the old one is called, it should not be called again. This function returns both a Source( and a finalizer which ensures that the > above two conditions hold. Once you call that finalizer, the Source is ! invalidated and cannot be used.  Since 0.5.2 7 !"#$% output value & finalizer '()True if Pipe ran to completion, False for early termination. *+,-./0123map initial input to new input 'map new leftovers to initial leftovers 456789, !"#$%&'()*+,-./0123456789,! "#$%&'()*+,-./56701234891! "#$%&'()*+,-./0123456789 None:%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 A Construct a # based on some IO actions for alloc/ release.  Since 0.3.0 BA combination of A and @.  Since 0.3.0 :;<=>?@Initial state Pull function A resource and/or state allocation  resource and/or state cleanup >Pull function. Note that this should not perform any cleanup. B resource and/or state allocation  resource and/or state cleanup GPull function. Note that this need not explicitly perform any cleanup. :;<=>?@AB:<;=?>@AB NoneCA 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 FA 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 I Construct a 7 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.3.0 J Construct a 3. Note that your push and close functions need not ! explicitly perform any cleanup.  Since 0.3.0 CDEFGHIinitial state push AClose. Note that the state is not returned, as it is not needed. J resource and/or state allocation  resource and/or state cleanup push close CDEFGHIJCEDFHGIJ None KHelper 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 LReturn value from a K.  Since 0.3.0 MPass control to a new conduit. NEnd the conduit. O+Set a new state, and emit some new output. PA 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 SA 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 V8A helper function for returning a list of values from a Conduit.  Since 0.3.0 W Construct a 7 with some stateful functions. This function addresses $ threading the state value for you.  Since 0.3.0 X Construct a .  Since 0.3.0 Y Convert a K into a .  Since 0.3.0 ICheck if input is available from upstream. Will not remove the data from  the stream.  Since 0.4.0 KLMNOPQRSTUV The next Conduit. to return after the list has been exhausted. &A close action for early termination. $The values to send down the stream. Winitial state Push function. QClose function. The state need not be returned, since it will not be used again. X 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. Yinitial state KLMNOPQRSTUVWXY KLONMPRQSUTVWXYNoneZECombines two sources. The new source will stop producing once either  source has been exhausted.  Since 0.3.0 [JCombines two sinks. The new sink will complete when both input sinks have  completed. Any leftovers are discarded.  Since 0.4.1 Z[":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ["@B=?>A:<;IFHGJCEDVWSUTXPRQKYLONMZ[Z[None \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 _KThe connect operator, which pulls data from a source and pushes to a sink. M When either side closes, the other side will immediately be closed as well.  If you would like to keep the Source open to be used for another 1 operations, use the connect-and-resume operator e.  Since 0.4.0 `HLeft fuse, combining a source and a conduit together into a new source.  Both the Source and Conduit' will be closed when the newly-created  Source is closed. Leftover data from the Conduit will be discarded.  Since 0.4.0 aERight fuse, combining a conduit and a sink together into a new sink.  Both the Conduit and Sink' will be closed when the newly-created Sink  is closed.  Leftover data returned from the Sink will be discarded.  Since 0.4.0 bFusion operator, combining two Conduits together into a new Conduit. Both Conduit(s will be closed when the newly-created Conduit is closed. &Leftover data returned from the right Conduit will be discarded.  Since 0.4.0 cFuse together two Pipe.s, connecting the output from the left to the  input of the right. Notice that the leftover parameter for the Pipe s must be Void. This N ensures that there is no accidental data loss of leftovers during fusion. If  you have a Pipe% with leftovers, you must first call /. For  example: :load Data.Conduit.List :set -XNoMonomorphismRestrictionDlet pipe = peek >>= \x -> fold (Prelude.+) 0 >>= \y -> return (x, y)5runPipe $ sourceList [1..10] >+> injectLeftovers pipe (Just 1,55) Since 0.5.0 dSame as c*, but reverse the order of the arguments.  Since 0.5.0 e9The connect-and-resume operator. This does not close the Source, but 4 instead returns it to be used again. This allows a Source to be used N incrementally in a large program, without forcing the entire program to live  in the Sink monad. Mnemonic: connect + do more.  Since 0.5.0 f#Continue processing after usage of $$+.  Since 0.5.0 gComplete processing of a ResumableSource. This will run the finalizer  associated with the ResumableSource). In order to guarantee process resource  finalization, you must use this operator after using $$+ and $$++.  Since 0.5.0 \]^_`abcdefg8 "#$%&'()./012389\]^_`abcdefg8_`abcd./"#$%&'()efg901238\^]   \^]_`abcdefgNoneh%Generate a source from a seed value.  Since 0.4.2 i8Enumerate from a value to a final value, inclusive, via . ,This is generally more efficient than using Prelude's  enumFromTo and  combining with  sourceList) since this avoids any intermediate data  structures.  Since 0.4.2 j@Produces an infinite stream of repeated applications of f to x. kA strict left fold.  Since 0.3.0 lA monadic strict left fold.  Since 0.3.0 mA monoidal strict left fold.  Since 0.5.3 n.Apply the action to all values in the stream.  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 n.  Since 0.3.0 u2Apply a monadic action on all values in a stream. This Conduit8 can be used to perform a monadic side-effect for every - value, whilst passing the value through the Conduit as-is.  0 iterM f = mapM (\a -> f a >>= \() -> return a)  Since 0.5.6 vKApply a transformation that may fail to all values in a stream, discarding  the failures.  Since 0.5.1 wHApply a monadic transformation that may fail to all values in a stream,  discarding the failures.  Since 0.5.1 x Filter the Just& values from a stream, discarding the Nothing values.  Since 0.5.1 yKApply a transformation to all values in a stream, concatenating the output  values.  Since 0.3.0 zHApply a monadic transformation to all values in a stream, concatenating  the output values.  Since 0.3.0 {y with an accumulator.  Since 0.3.0 |z with an accumulator.  Since 0.3.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.3.0 ~2Grouping 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 JA source that outputs no values. Note that this is just a type-restricted  synonym for .  Since 0.3.0 Run a Pipe; repeatedly, and output its result value downstream. Stops 0 when no more input is available from upstream.  Since 0.5.0 hijklmnopqrstuvwxyz{|}~Pipe to run repeatedly 4hijklmnopqrstuvwxyz{|}~4hijkmpoqr}lnsvxy{~tuwz|hijklmnopqrstuvwxyz{|}~None.Stream the contents of a file as binary data.  Since 0.3.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.3.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 closed it as soon as possible.  Since 0.3.0 &Stream all incoming data to the given . Note that this function  will not automatically close the Handle when processing completes.  Since 0.3.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.3.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.3.0 ,Stream all incoming data to the given file.  Since 0.3.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.3.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.3.0 4Return the next byte from the stream, if available.  Since 0.3.0 -Return all bytes while the predicate returns True.  Since 0.3.0 -Ignore all bytes while the predicate returns True.  Since 0.3.0 .Take the given number of bytes, if available.  Since 0.3.0 &Drop up to the given number of bytes.  Since 0.5.0 GSplit the input bytes into lines. In other words, split on the LF byte % (10), and strip it from the output.  Since 0.3.0 *Stream the chunks from a lazy bytestring.  Since 0.5.0 Offset Maximum count None  Since 0.3.0 A specific character encoding.  Since 0.3.0 Emit each line separately  Since 0.4.1 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.3.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.3.0  Since 0.3.0  Since 0.3.0  Since 0.3.0  Since 0.3.0  Since 0.3.0  Since 0.3.0  Since 0.3.0  None 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   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH 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 hijkklmnopqrstuvwxyz{|}~~}  conduit-0.5.6 Data.ConduitData.Conduit.InternalData.Conduit.ListData.Conduit.UtilData.Conduit.BinaryData.Conduit.TextData.Conduit.LazySystem.PosixFileData.Conduit.Util.SourceData.Conduit.Util.SinkData.Conduit.Util.Conduitmonad-control-0.3.2.1Control.Monad.Trans.ControlMonadBaseControlresourcet-0.4.8Control.Monad.Trans.Resource runException_ runExceptionrunExceptionT_ runResourceT%Control.Monad.Trans.Resource.Internal MonadResource monadThrow MonadThrow ResourceT runExceptionT ExceptionT unsafeLiftIO MonadUnsafeIOResumableSource GLInfConduit GInfConduit GLConduitGConduitConduit GLInfSinkGInfSinkGLSinkGSinkSinkGSourceSourcePipeLeftoverPipeMDone NeedInput HaveOutputawaitawaitE awaitForeveryieldyieldOrleftoverbracketP addCleanupidPpipepipeL connectResumerunPipeinjectLeftovers transPipe mapOutputmapOutputMaybemapInput sourceList sourceToPipe sinkToPipe conduitToPipe withUpstreamunwrapResumableSourceIOResultIOClosedIOOpenSourceStateResult StateClosed StateOpen sourceStatesourceIO sourceStateIO SinkIOResult IOProcessingIODoneSinkStateResultStateProcessing StateDone sinkStatesinkIO SequencedSinkSequencedSinkResponse StartConduitStopEmitConduitIOResult IOProducing IOFinishedConduitStateResultStateProducing StateFinishedhaveMore conduitState conduitIO sequenceSinkzipzipSinksFlushChunk$$$==$=$=>+><+<$$+$$++$$+-unfold enumFromToiteratefoldfoldMfoldMapmapM_droptakeheadpeekmapmapMiterMmapMaybe mapMaybeM catMaybes concatMap concatMapMconcatMapAccumconcatMapAccumMconsumegroupByisolatefiltersinkNull sourceNullsequence sourceFile sourceHandlesourceIOHandle sinkHandle sinkIOHandlesourceFileRangesinkFile conduitFile takeWhile dropWhilelines sourceLbsCodecencodedecodeutf8utf16_leutf16_beutf32_leutf32_beascii iso8859_1 lazyConsumeFDFlagclosec_readc_openoRdonlyopenReadreadbaseGHC.Basefmapbuild$fMonadResourcePipe $fMonoidPipe$fMonadActivePipe$fMonadThrowPipe $fMonadIOPipe$fMonadTransPipe$fMonadBasebasePipe $fMonadPipe$fApplicativePipe $fFunctorPipehasInputpipePush$fFunctorConduitIOResult$fFunctorConduitStateResult$fFunctorFlushGHC.Enumsucc Data.MonoidmemptyGHC.IO.Handle.TypesHandle TextExceptionEncodeExceptionDecodeException codecName codecEncode codecDecode byteSplits splitSlowly utf16Requiredutf32SplitBytes tryEvaluate maybeDecode$fExceptionTextException $fShowCodec monadActive