J      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Trustworthy;<=>?FNQTVZw!XThe 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 i> 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 (oQ), 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.0WProvide new output to be sent downstream. This constructor has three fields: the next Pipe< to be used, a finalization function, and the output value.^Request more input from upstream. The first field takes a new input value and provides a new Pipei. The second takes an upstream result value, which indicates that upstream is producing no more results.Processing with this Pipe) is complete, providing the final result.4Require running of a monadic action to get the next Pipe.EReturn leftover input, which should be provided to future operations.,Wait for a single input value from upstream. Since 0.5.0This is similar to await0, but will return the upstream result value as Left if available. Since 0.5.00Wait 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 yieldB, 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 Bracket a pipe computation between allocation and release of a resource. Two guarantees are given about resource finalization:  It will be prompt4. The finalization will be run as early as possible.&It is exception safe. Due to usage of  resourcetB, 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.0Compose 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.0Same as , but automatically applies  to the right Pipe. Since 0.5.0*Run a pipeline until processing completes. Since 0.5.0 Transforms a PipeL 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 awaitT. If there are more leftover values than are demanded, the remainder are discarded. Since 0.5.0Transform the monad that a Pipe lives in.Note that the monad transforming function will be run multiple times, resulting in unintuitive behavior in some cases. For a fuller treatment, please see: Hhttps://github.com/snoyberg/conduit/wiki/Dealing-with-monad-transformers$This function is just a synonym for . Since 0.4.0/Apply a function to all the output values of a Pipe.This mimics the behavior of  for a Source and Conduit in pre-0.4 days. Since 0.4.1Same as ", but use a function that returns Maybe values. Since 0.5.0.Apply a function to all the input values of a Pipe. Since 0.5.0Convert a list into a source. Since 0.3.0The equivalent of GHC.Exts.build for Pipe. Since 0.4.2zReturns a tuple of the upstream and downstream results. Note that this will force consumption of the entire input stream. Since 0.5.0Fuse together two PipeBs, connecting the output from the left to the input of the right.Notice that the leftover parameter for the Pipe s must be Voida. This ensures that there is no accidental data loss of leftovers during fusion. If you have a Pipe% with leftovers, you must first call . Since 0.5.0Same as ), but reverse the order of the arguments. Since 0.5.0See catchC for more details. Since 1.0.11 The same as  flip catchP. Since 1.0.11See tryC for more details. Since 1.0.11 +Generalize the upstream return value for a Pipe from unit to any type. Since 1.1.5 Since 1.0.4  output value  finalizer -computation to run first ("acquire resource"),computation to run last ("release resource")computation to run in-betweenTrue if Pipe ran to completion, False for early termination.map initial input to new input&map new leftovers to initial leftovers!  9 9  Trustworthy3;<=>?FNQTV0@!Provides an alternative  Applicative instance for ConduitM=. In this instance, every incoming value is provided to all ConduitM@s, and output is coalesced together. Leftovers from individual ConduitMs will be used within that component, and then discarded at the end of their computation. Output and finalizers will both be handled in a left-biased manner.*As an example, take the following program: main :: IO () main = do let src = mapM_ yield [1..3 :: Int] conduit1 = CL.map (+1) conduit2 = CL.concatMap (replicate 2) conduit = getZipConduit $ ZipConduit conduit1 <* ZipConduit conduit2 sink = CL.mapM_ print src $$ conduit =$ sink 5It will produce the output: 2, 1, 1, 3, 2, 2, 4, 3, 3 Since 1.0.17$A wrapper for defining an  instance for 38s which allows to combine sinks together, generalizing D. A combined sink distributes the input to all its participants and when all finish, produces the result. This allows to define functions like {sequenceSinks :: (Monad m) => [Sink i m r] -> Sink i m [r] sequenceSinks = getZipSink . sequenceA . fmap ZipSink Note that the standard  instance for conduits works differently. It feeds one sink with input until it finishes, then switches to another, etc., and at the end combines their results.6This newtype is in fact a type constrained version of !d, and has the same behavior. It's presented as a separate type since (1) it historically predates  ZipConduit{, and (2) the type constraining can make your code clearer (and thereby make your error messages more easily understood). Since 1.0.13'A wrapper for defining an  instance for 5:s which allows to combine sources together, generalizing E>. A combined source will take input yielded from each of its Source+s until any of them stop producing output. Since 1.0.13*1Provide for a stream of data that can be flushed. A number of Conduits (e.g., zlib compression) need the ability to flush the stream at some point. This provides a single wrapper datatype to be used in all such circumstances. Since 0.3.0-A generalization of /b. Allows to resume an arbitrary conduit, keeping its state and using it later (or finalizing it). Since 1.0.17/A Source3 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.01lConsumes a stream of input values and produces a stream of output values, without producing a final result. Since 0.5.02uA component which consumes a stream of input values and produces a final result, regardless of the output stream. A Consumer is a generalization of a Sink, and can be used as either a Sink or a Conduit. Since 1.0.03]Consumes a stream of input values and produces a final result, without producing any output. %type Sink i m r = ConduitM i Void m r Since 0.5.04YA component which produces a stream of output values, regardless of the input stream. A Producer is a generalization of a Source, and can be used as either a Source or a Conduit. Since 1.0.05]Provides a stream of output values, without consuming any input or producing a final result. Since 0.5.06{Core datatype of the conduit package. This type represents a general component which can consume a stream of input values i%, produce a stream of output values o, perform actions in the m$ monad, and produce a final result rH. The type synonyms provided here are simply wrappers around this type. Since 1.0.09 Connect a Source to a SinkE 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= Unwraps a ResumableSource into a Source and a finalizer.A ResumableSource represents a Source{ which has already been run, and therefore has a finalizer registered. As a result, if we want to turn it into a regular Source\, we need to ensure that the finalizer will be run appropriately. By appropriately, I mean:CIf a new finalizer is registered, the old one should not be called.8If the old one is called, it should not be called again.This function returns both a Sourcef 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>Turn a Source into a ResumableSource with no attached finalizer. Since 1.1.4? Generalize a 5 to a 4. Since 1.0.0@ Generalize a 3 to a 2. Since 1.0.0AECatch all exceptions thrown by the current component of the pipeline.Note: this will not[ catch exceptions thrown by other components! For example, if an exception is thrown in a Source feeding to a Sink , and the Sink uses catchC, the exception will not be caught.wDue to this behavior (as well as lack of async exception safety), you should not try to implement combinators such as  onException& in terms of this primitive function.+Note also that the exception handling will not9 be applied to any finalizers generated by this conduit. Since 1.0.11B The same as  flip catchC. Since 1.0.11C A version of try0 for use within a pipeline. See the comments in catchC for more details. Since 1.0.11DWCombines two sinks. The new sink will complete when both input sinks have completed.Any leftovers are discarded. Since 0.4.1EbCombines two sources. The new source will stop producing once either source has been exhausted. Since 1.0.13FbCombines two sources. The new source will stop producing once either source has been exhausted. Since 1.0.13G Since 1.0.17HSame as normal fusion (e.g. =$=V), except instead of discarding leftovers from the downstream component, return them. Since 1.0.17I Similar to fuseReturnLeftoversW, but use the provided function to convert downstream leftovers to upstream leftovers. Since 1.0.17J Connect a -B to a sink and return the output of the sink together with a new -. Since 1.0.17K Unwraps a ResumableConduit into a Conduit and a finalizer.Since = for more information. Since 1.0.17LTurn a Conduit into a ResumableConduit with no attached finalizer. Since 1.1.4MMerge a Source into a Conduit[. The new conduit will stop processing once either source or upstream have been exhausted.NTurn a Sink into a Conduit in the following way:All input passed to the Sink is yielded downstream. When the SinkU finishes processing, the result is passed to the provided to the finalizer function.Note that the SinkT will stop receiving input as soon as the downstream it is connected to shuts down.3An example usage would be to write the result of a SinkG to some mutable variable while allowing other processing to continue. Since 1.1.0O Convert a Source: into a list. The basic functionality can be explained as: 3sourceToList src = src $$ Data.Conduit.List.consume However,  sourceToListv is able to produce its results lazily, which cannot be done when running a conduit pipeline in general. Unlike the Data.Conduit.Lazy module (in conduit-extra), this function performs no unsafe I/O operations, and therefore can only be as lazily as the underlying monad. Since 1.2.6PjThe connect operator, which pulls data from a source and pushes to a sink. If you would like to keep the SourceL open to be used for other operations, use the connect-and-resume operator a. Since 0.4.0QA synonym for S for backwards compatibility. Since 0.4.0RA synonym for S for backwards compatibility. Since 0.4.0SFusion 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.0TOWait for a single input value from upstream. If no data is available, returns Nothing. Once await returns Nothing%, subsequent calls will also return Nothing. Since 0.5.0USend a value downstream to the next component to consume. If the downstream component terminates, this call will never return control. If you would like to register a cleanup function, please use [ instead. Since 0.5.0VBSend a monadic value downstream for the next component to consume.WnProvide a single piece of leftover input to be consumed by the next component in the current monadic binding.Noted: it is highly encouraged to only return leftover values from input already consumed from upstream.X*Run a pipeline until processing completes. Since 1.2.1YBracket a conduit computation between allocation and release of a resource. Two guarantees are given about resource finalization:  It will be prompt4. 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.0Z;Add some code to be run when the given component cleans up..The supplied cleanup function will be given a True) if the component ran to completion, or FalseC if it terminated early due to a downstream component terminating.ENote that this function is not exception safe. For that, please use Y. Since 0.4.1[ Similar to UW, but additionally takes a finalizer to be run if the downstream component terminates. Since 0.5.0\WWait for input forever, calling the given inner component for each piece of new input.FThis function is provided as a convenience for the common pattern of awaiting input, checking if it's Just and then looping. Since 0.5.0]Transform the monad that a ConduitM lives in.Note that the monad transforming function will be run multiple times, resulting in unintuitive behavior in some cases. For a fuller treatment, please see: Hhttps://github.com/snoyberg/conduit/wiki/Dealing-with-monad-transformers$This function is just a synonym for . Since 0.4.0^/Apply a function to all the output values of a ConduitM.This mimics the behavior of  for a 5 and 1? in pre-0.4 days. It can also be simulated by fusing with the map conduit from Data.Conduit.List. Since 0.4.1_Same as ^", but use a function that returns Maybe values. Since 0.5.0`.Apply a function to all the input values of a ConduitM. Since 0.5.0a9The connect-and-resume operator. This does not close the Source:, but instead returns it to be used again. This allows a Sourceb to be used incrementally in a large program, without forcing the entire program to live in the Sink monad.Mnemonic: connect + do more. Since 0.5.0b#Continue processing after usage of $$+. Since 0.5.0cComplete processing of a ResumableSource3. 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.0d#Left fusion for a resumable source. Since 1.0.16e(Execute the finalizer associated with a ResumableSource, rendering the ResumableSource invalid for further use.(This is just a more explicit version of $$+- return (). Since 1.1.3f*Coalesce all values yielded by all of the Sources.Implemented on top of  ZipSourceA and as such, it exhibits the same short-circuiting behavior as  ZipSource|. See that data type for more details. If you want to create a source that yields *all* values from multiple sources, use . Since 1.0.13g#Send incoming values to all of the Sink@ providing, and ultimately coalesce together all return values.Implemented on top of ZipSink&, see that data type for more details. Since 1.0.13h9The connect-and-resume operator. This does not close the Conduit:, but instead returns it to be used again. This allows a Conduitb to be used incrementally in a large program, without forcing the entire program to live in the Sink monad. Leftover data returned from the Sink will be discarded.Mnemonic: connect + do more. Since 1.0.17i#Continue processing after usage of h . Connect a -C to a sink and return the output of the sink together with a new -. Since 1.0.17jComplete processing of a -3. This will run the finalizer associated with the ResumableConduit<. In order to guarantee process resource finalization, you must use this operator after using h and i. Since 1.0.17k&Provide identical input to all of the Conduit2s and combine their outputs into a single stream.Implemented on top of  ZipConduit&, see that data type for more details. Since 1.0.17l Fuse two ConduitMas together, and provide the return value of both. Note that this will force the entire upstream ConduitMQ to be run to produce the result value, even if the downstream terminates early. Since 1.1.5mLike l(, but does not force consumption of the Producer. In the case that the Producer0 terminates, the result value is provided as a Just* value. If it does not terminate, then a Nothing value is returned.FOne thing to note here is that "termination" here only occurs if the Producer actually yields a Nothing value. For example, with the Producer mapM_ yield [1..5]%, if five values are requested, the Producer^ has not yet terminated. Termination only occurs when the sixth value is awaited for and the Producer signals termination. Since 1.2.4nSame as fuseBoth3, but ignore the return value from the downstream Conduit+. Same caveats of forced consumption apply. Since 1.1.5 Since 1.0.13N finalizerU output valueY-computation to run first ("acquire resource"),computation to run last ("release resource")computation to run in-between[ finalizer`map initial input to new input&map new leftovers to initial leftoversN!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn!"#$%&'()*+,-./0678 P0Q1R2S2a0b0c0d1h0i0j0 Trustworthy3CQV5*xjThis is the same as stream fusion's Step. Constructors are renamed to avoid confusion with conduit names.opqrstuvwxyz{|}~xyz{vwutsrqpo}~|u vwxyz{ TrustworthyNQV6I++Safe3<QVCINamed function synonym for P. Since 1.2.3Named function synonym for S. Since 1.2.3 Combine two Conduits together into a new Conduit (aka ).Output from the upstream (left) conduit will be fed into the downstream (right) conduit. Processing will terminate when downstream (right) returns. Leftover data returned from the right Conduit will be discarded.FRun a pure pipeline until processing completes, i.e. a pipeline with Identity, as the base monad. This is equivalient to runIdentity . runConduit.-Run a pipeline which acquires resources with  ResourceT, and then run the  ResourceT% transformer. This is equivalent to runResourceT . runConduit.upstream downstreamF!"#$%&'()*+,-/123456=>?@ABCHIKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnF5136PQRSlmnTUVWXYZ[ABC42?@\]^_`MNO/>abcd=e-LhijKIH*+,'()f$%&g!"#k2SafeEt  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSXabcdefghijklmnopqrstuvwxyz{|}~o  67854321/0-.*+,'()$%&!"#T\UV[WX9JIHabcdhijPQRS:;<?@YZABC]^_`e=K>LDEFGMNOlmnfgkSafeQV_"Wrap the base monad in   Since 1.2.12Run   in the base monad Since 1.2.12 Catch an error in the base monad Since 1.2.12Wrap the base monad in   Since 1.0.11Run   in the base monad Since 1.0.11 Catch an error in the base monad Since 1.0.11Run   in the base monad Since 1.1.0$Catch an exception in the base monad Since 1.1.0Wrap the base monad in   Since 1.0.11Run   in the base monad Since 1.0.11Wrap the base monad in  Since 1.0.11Run  in the base monad Since 1.0.11Wrap the base monad in  Since 1.0.11Run  in the base monad Since 1.0.11 Evaluate  in the base monad Since 1.0.11Execute  in the base monad Since 1.0.11Wrap the base monad in  Since 1.0.11Run  in the base monad Since 1.0.11 Evaluate  in the base monad Since 1.0.11Execute  in the base monad Since 1.0.11Wrap the base monad in  Since 1.0.11Run  in the base monad Since 1.0.11Execute  in the base monad Since 1.0.11Wrap the base monad in  Since 1.0.11Run  in the base monad Since 1.0.11Execute  in the base monad Since 1.0.11Wrap the base monad in  Since 1.0.11Run  in the base monad Since 1.0.11 Evaluate  in the base monad Since 1.0.11Execute  in the base monad Since 1.0.11Wrap the base monad in  Since 1.0.11Run  in the base monad Since 1.0.11 Evaluate  in the base monad Since 1.0.11Execute  in the base monad Since 1.0.11## TrustworthyQVvS$Generate a source from a seed value.Subject to fusion Since 0.4.2$Generate a source from a seed value.Subject to fusion Since 0.4.2 8Generate a source from a seed value with a return value.Subject to fusion 8Generate a source from a seed value with a return value.Subject to fusionA monadic unfold.Subject to fusion Since 1.1.2A monadic unfold.Subject to fusion Since 1.1.2 A monadic unfoldEither.Subject to fusion A monadic unfoldEither.Subject to fusionYield the values from the list.Subject to fusionYield the values from the list.Subject to fusion8Enumerate from a value to a final value, inclusive, via succ.,This is generally more efficient than using Prelude's  enumFromTo and combining with  sourceList5 since this avoids any intermediate data structures.Subject to fusion Since 0.4.28Enumerate from a value to a final value, inclusive, via succ.,This is generally more efficient than using Prelude's  enumFromTo and combining with  sourceList5 since this avoids any intermediate data structures.Subject to fusion Since 0.4.2?Produces an infinite stream of repeated applications of f to x.Subject to fusion?Produces an infinite stream of repeated applications of f to x.Subject to fusion3Replicate a single value the given number of times.Subject to fusion Since 1.2.03Replicate a single value the given number of times.Subject to fusion Since 1.2.04Replicate a monadic value the given number of times.Subject to fusion Since 1.2.04Replicate a monadic value the given number of times.Subject to fusion Since 1.2.0A strict left fold.Subject to fusion Since 0.3.0A strict left fold.Subject to fusion Since 0.3.0A monadic strict left fold.Subject to fusion Since 0.3.0A monadic strict left fold.Subject to fusion Since 0.3.0A monoidal strict left fold.Subject to fusion Since 0.5.3'A monoidal strict left fold in a Monad. Since 1.0.8 -Apply the action to all values in the stream.Subject to fusion Since 0.3.0-Apply the action to all values in the stream.Subject to fusion Since 0.3.0!^Ignore a certain number of values in the stream. This function is semantically equivalent to: drop i = take i >> return () However, dropA is more efficient as it does not need to hold values in memory.Subject to fusion Since 0.3.0^Ignore a certain number of values in the stream. This function is semantically equivalent to: drop i = take i >> return () However, dropA is more efficient as it does not need to hold values in memory.Subject to fusion Since 0.3.0"Take 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 =$ consumeSubject to fusion Since 0.3.0Take 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 =$ consumeSubject to fusion Since 0.3.0#2Take a single value from the stream, if available.Subject to fusion Since 0.3.02Take a single value from the stream, if available.Subject to fusion Since 0.3.0kLook at the next value in the stream, if available. This function will not change the state of the stream. Since 0.3.0$1Apply a transformation to all values in a stream.Subject to fusion Since 0.3.01Apply a transformation to all values in a stream.Subject to fusion Since 0.3.0%9Apply a monadic transformation to all values in a stream.vIf you do not need the transformed values, and instead just want the monadic side-effects of running the action, see .Subject to fusion Since 0.3.09Apply a monadic transformation to all values in a stream.vIf you do not need the transformed values, and instead just want the monadic side-effects of running the action, see .Subject to fusion Since 0.3.0&1Apply a monadic action on all values in a stream.This Conduite can be used to perform a monadic side-effect for every value, whilst passing the value through the Conduit as-is. .iterM f = mapM (\a -> f a >>= \() -> return a)Subject to fusion Since 0.5.61Apply a monadic action on all values in a stream.This Conduite can be used to perform a monadic side-effect for every value, whilst passing the value through the Conduit as-is. .iterM f = mapM (\a -> f a >>= \() -> return a)Subject to fusion Since 0.5.6'YApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1YApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1(aApply a monadic transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1aApply a monadic transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1) Filter the Just& values from a stream, discarding the Nothing values.Subject to fusion Since 0.5.1 Filter the Just& values from a stream, discarding the Nothing values.Subject to fusion Since 0.5.1*Generalization of . It puts all values from + into stream.Subject to fusion Since 1.0.6Generalization of . It puts all values from + into stream.Subject to fusion Since 1.0.6,SApply a transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0SApply a transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0-[Apply a monadic transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0[Apply a monadic transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0. with a strict accumulator.Subject to fusion Since 0.3.0 with a strict accumulator.Subject to fusion Since 0.3.0Deprecated synonym for mapAccum Since 1.0.6Deprecated synonym for  mapAccumM Since 1.0.6/ Analog of  mapAccumL% for lists. Note that in contrast to  mapAccumL, the function argument takes the accumulator as its second argument, not its first argument, and the accumulated value is strict.Subject to fusion Since 1.1.1 Analog of  mapAccumL% for lists. Note that in contrast to  mapAccumL, the function argument takes the accumulator as its second argument, not its first argument, and the accumulated value is strict.Subject to fusion Since 1.1.10Monadic .Subject to fusion Since 1.1.1Monadic .Subject to fusion Since 1.1.1 Analog of 1 for lists.Subject to fusion Since 1.1.1Monadic scanl.Subject to fusion Since 1.1.12 with a strict accumulator.Subject to fusion Since 0.3.0 with a strict accumulator.Subject to fusion Since 0.3.03Generalization of  and S. It applies function to all values in a stream and send values inside resulting Foldable downstream.Subject to fusion Since 1.0.6Generalization of  and S. It applies function to all values in a stream and send values inside resulting Foldable downstream.Subject to fusion Since 1.0.64Monadic variant of .Subject to fusion Since 1.0.6Monadic variant of .Subject to fusion Since 1.0.65jConsume all values from the stream and return as a list. Note that this will pull all values into memory.Subject to fusion Since 0.3.0jConsume all values from the stream and return as a list. Note that this will pull all values into memory.Subject to fusion Since 0.3.0^Group a stream into chunks of a given size. The last chunk may contain fewer than n elements.Subject to fusion Since 1.2.961Grouping input according to an equality function.Subject to fusion Since 0.3.01Grouping input according to an equality function.Subject to fusion Since 0.3.07 is similar to  groupBy idreturns a pair, indicating there are always 1 or more items in the grouping. This is designed to be converted into a NonEmpty structure but it avoids a dependency on another package import Data.List.NonEmpty groupOn1 :: (Monad m, Eq b) => (a -> b) -> Conduit a m (NonEmpty a) groupOn1 f = CL.groupOn1 f =$= CL.map (uncurry (:|))Subject to fusion Since 1.1.7 is similar to  groupBy idreturns a pair, indicating there are always 1 or more items in the grouping. This is designed to be converted into a NonEmpty structure but it avoids a dependency on another package import Data.List.NonEmpty groupOn1 :: (Monad m, Eq b) => (a -> b) -> Conduit a m (NonEmpty a) groupOn1 f = CL.groupOn1 f =$= CL.map (uncurry (:|))Subject to fusion Since 1.1.78bEnsure 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 values. To get the latter behavior, combine with , e.g.: xsrc $$ do x <- isolate count =$ do x <- someSink sinkNull return x someOtherSink ...Subject to fusion Since 0.3.0bEnsure 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 values. To get the latter behavior, combine with , e.g.: xsrc $$ do x <- isolate count =$ do x <- someSink sinkNull return x someOtherSink ...Subject to fusion Since 0.3.099Keep only values in the stream passing a given predicate.Subject to fusion Since 0.3.09Keep only values in the stream passing a given predicate.Subject to fusion Since 0.3.0:VIgnore the remainder of values in the source. Particularly useful when combined with .Subject to fusion Since 0.3.0VIgnore the remainder of values in the source. Particularly useful when combined with .Subject to fusion Since 0.3.0;WA source that outputs no values. Note that this is just a type-restricted synonym for <.Subject to fusion Since 0.3.0WA source that outputs no values. Note that this is just a type-restricted synonym for <.Subject to fusion Since 0.3.0Run a Pipej repeatedly, and output its result value downstream. Stops when no more input is available from upstream. Since 0.5.0Pipe to run repeatedly..=      !"#$%&'()**+,,-../01022334567899:;<=>?@ABCDEFGHIJKLMNOPQRSTUV WXYZ[\]^_`abcdefghijkllmnopqrstuvwxyz{|}~"!k      !"#$%&'()*+,-./0123456789:;<=>%conduit-1.2.13-IKlIGyToZRv9yZ0JeMDBHdData.Conduit.Internal Data.ConduitData.Conduit.Internal.Fusion!Data.Conduit.Internal.List.StreamData.Conduit.LiftData.Conduit.ListData.Conduit.Internal.PipeData.Conduit.Internal.ConduitPipe HaveOutput NeedInputDonePipeMLeftoverawaitawaitE awaitForeveryieldyieldMyieldOrleftoverbracketP addCleanupidPpipepipeLrunPipeinjectLeftovers transPipe mapOutputmapOutputMaybemapInput enumFromTo sourceList withUpstream>+><+<catchPhandlePtryPgeneralizeUpstream ZipConduit getZipConduitZipSink getZipSink ZipSource getZipSourceFlushChunkResumableConduitResumableSourceConduitConsumerSinkProducerSourceConduitM unConduitM connectResume sourceToPipe sinkToPipe conduitToPipeunwrapResumablenewResumableSource toProducer toConsumercatchChandleCtryCzipSinks zipSources zipSourcesApp zipConduitAppfuseReturnLeftovers fuseLeftoversconnectResumeConduitunwrapResumableConduitnewResumableConduit mergeSourcepassthroughSink sourceToList$$$==$=$= runConduit$$+$$++$$+-$=+closeResumableSourcesequenceSources sequenceSinks=$$+=$$++=$$+-sequenceConduitsfuseBoth fuseBothMaybe fuseUpstreamStreamConsumer StreamSinkStreamProducer StreamSource StreamConduitStreamConduitMConduitWithStreamStreamStepEmitSkipStopunstream streamConduit streamSourcestreamSourcePure $fFunctorStep GroupByStateGBStartGBLoopGBDoneunfoldS unfoldEitherSunfoldMSunfoldEitherMS sourceListS enumFromToSenumFromToS_intiterateS replicateS replicateMSfoldSfoldMSmapM_SdropStakeSheadSmapSmapMSiterMS mapMaybeS mapMaybeMS catMaybesSconcatS concatMapS concatMapMSconcatMapAccumS mapAccumS mapAccumMSconcatMapAccumMS mapFoldableS mapFoldableMSconsumeSgroupByS groupOn1S groupBy1SisolateSfilterS sinkNullS sourceNullSconnectfuse.|runConduitPure runConduitRes distributeexceptC runExceptC catchExceptCerrorC runErrorC catchErrorC runCatchC catchCatchCmaybeC runMaybeCreaderC runReaderCstateLC runStateLC evalStateLC execStateLCstateC runStateC evalStateC execStateCwriterLC runWriterLC execWriterLCwriterC runWriterC execWriterCrwsLCrunRWSLC evalRWSLC execRWSLCrwsCrunRWSCevalRWSCexecRWSCunfold unfoldEitherunfoldM unfoldEitherMiterate replicate replicateMfoldfoldMfoldMapfoldMapMmapM_droptakeheadpeekmapmapMiterMmapMaybe mapMaybeM catMaybesconcat concatMap concatMapMconcatMapAccumscanlscanlMmapAccum mapAccumMscanscanMconcatMapAccumM mapFoldable mapFoldableMconsumechunksOfgroupBygroupOn1isolatefiltersinkNull sourceNullsequence#mmorph-1.1.0-66Wi5WnKrYM86tQZg3s0IxControl.Monad.MorphhoistbaseGHC.Basefmapbuild$fMFunctorTYPEPipe Applicative Data.Foldable sequence_$fMFunctorTYPEResumableSourcetransformers-0.5.2.0Control.Monad.Trans.ExceptExceptTControl.Monad.Trans.ErrorErrorT'exceptions-0.8.3-6TQSgd6QYnC83Uf6EwjUmsControl.Monad.Catch.PureCatchTControl.Monad.Trans.MaybeMaybeTControl.Monad.Trans.ReaderReaderTControl.Monad.Trans.State.LazyStateT Control.Monad.Trans.State.StrictControl.Monad.Trans.Writer.LazyWriterT!Control.Monad.Trans.Writer.StrictControl.Monad.Trans.RWS.LazyRWSTControl.Monad.Trans.RWS.StrictunfoldC unfoldEitherCunfoldMCunfoldEitherMC sourceListC enumFromToCiterateC replicateC replicateMCfoldCfoldMCmapM_CdropCtakeCheadCmapCmapMCiterMC mapMaybeC mapMaybeMC catMaybesCconcatCFoldable concatMapC concatMapMCconcatMapAccumC mapAccumC mapAccumMCGHC.ListconcatMapAccumMC mapFoldableC mapFoldableMCconsumeCgroupByC groupOn1CisolateCfilterC sinkNullC sourceNullCmempty