!~-      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+, - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                          !"#$%&'()*+,  Trustworthy;<=>?FNQTVgconduitXThe 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.0conduitUProvide new output to be sent downstream. This constructor has two fields: the next Pipe! to be used and the output value.conduit^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.conduitProcessing with this Pipe) is complete, providing the final result. conduit4Require running of a monadic action to get the next Pipe.!conduitEReturn leftover input, which should be provided to future operations."conduit,Wait for a single input value from upstream. Since 0.5.0#conduitThis is similar to await0, but will return the upstream result value as Left if available. Since 0.5.0$conduit0Wait for input forever, calling the given inner Pipe@ for each piece of new input. Returns the upstream result type. Since 0.5.0%conduit9Send a single output value downstream. If the downstream Pipe terminates, this Pipe will terminate as well. Since 0.5.0'conduitiProvide 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(conduit`Bracket a pipe computation between allocation and release of a resource. We guarantee, via the  MonadResourceb context, that the resource finalization is exception safe. However, it will not necessarily be prompt1, in that running a finalizer may wait until the  ResourceT block exits. Since 0.5.0)conduit The identity Pipe. Since 0.5.0*conduit<Compose a left and right pipe together into a complete pipe. Since 0.5.0+conduitSame as *, but automatically applies - to the right Pipe. Since 0.5.0,conduit*Run a pipeline until processing completes. Since 0.5.0-conduit 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.0.conduitTransform 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 hoist. Since 0.4.0/conduit/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.10conduitSame as /", but use a function that returns Maybe values. Since 0.5.01conduit.Apply a function to all the input values of a Pipe. Since 0.5.03conduitConvert a list into a source. Since 0.3.0.conduitThe equivalent of GHC.Exts.build for Pipe. Since 0.4.24conduitzReturns a tuple of the upstream and downstream results. Note that this will force consumption of the entire input stream. Since 0.5.05conduitFuse 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.06conduitSame as 5), but reverse the order of the arguments. Since 0.5.07conduitSee catchC for more details. Since 1.0.118conduit The same as  flip catchP. Since 1.0.119conduitSee tryC for more details. Since 1.0.11:conduit+Generalize the upstream return value for a Pipe from unit to any type. Since 1.1.5%conduit output value(conduit-computation to run first ("acquire resource")conduit,computation to run last ("release resource")conduitcomputation to run in-between1conduitmap initial input to new inputconduit&map new leftovers to initial leftovers !"#$%&'()*+,-./0123456789:59 69   Trustworthy3;<=>?FNQTVB>;conduitProvides an alternative  Applicative instance for ConduitT=. In this instance, every incoming value is provided to all ConduitT@s, and output is coalesced together. Leftovers from individual ConduitTs 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>conduitA wrapper for defining an / instance for I8s which allows to combine sinks together, generalizing ]. 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.13AconduitA wrapper for defining an / instance for K:s which allows to combine sources together, generalizing ^>. A combined source will take input yielded from each of its Source+s until any of them stop producing output. Since 1.0.13Dconduit1Provide 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.0GconduitlConsumes a stream of input values and produces a stream of output values, without producing a final result. Since 0.5.0HconduituA 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.0Iconduit]Consumes a stream of input values and produces a final result, without producing any output. %type Sink i m r = ConduitT i Void m r Since 0.5.0JconduitYA 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.0Kconduit]Provides a stream of output values, without consuming any input or producing a final result. Since 0.5.0LconduitSame as O, for backwards compatMconduit<In order to provide for efficient monadic composition, the ConduitT type is implemented internally using a technique known as the codensity transform. This allows for cheap appending, but makes one case much more expensive: partially running a ConduitT# and that capturing the new state.This data type is the same as ConduitT6, but does not use the codensity transform technique.Oconduit{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.3.0Tconduit 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. Since 0.5.0Xconduit Generalize a K to a J. Since 1.0.0Yconduit Generalize a I to a H. Since 1.0.0ZconduitECatch 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.11[conduit The same as  flip catchC. Since 1.0.11\conduit A version of try0 for use within a pipeline. See the comments in catchC for more details. Since 1.0.11]conduitWCombines two sinks. The new sink will complete when both input sinks have completed.Any leftovers are discarded. Since 0.4.1^conduitbCombines two sources. The new source will stop producing once either source has been exhausted. Since 1.0.13_conduitbCombines two sources. The new source will stop producing once either source has been exhausted. Since 1.0.13`conduit Since 1.0.17aconduitSame as normal fusion (e.g. =$=V), except instead of discarding leftovers from the downstream component, return them. Since 1.0.17bconduit Similar to fuseReturnLeftoversW, but use the provided function to convert downstream leftovers to upstream leftovers. Since 1.0.17cconduit Connect a GB to a sink and return the output of the sink together with a new G. Since 1.0.17dconduitMerge a Source into a Conduit[. The new conduit will stop processing once either source or upstream have been exhausted.econduitTurn 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.0fconduit 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.6gconduitEquivalent to using r and i together. Since 1.2.3hconduitNamed function synonym for iEquivalent to i and mM. However, the latter is deprecated and will be removed in a future version. Since 1.2.3iconduit Combine two Conduits together into a new Conduit (aka h).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.Equivalent to h and mL, however the latter is deprecated and will be removed in a future version.INote that, while this operator looks like categorical composition (from Control.Category*), there are a few reasons it's different:'The position of the type parameters to O* do not match. We would need to change ConduitT i o m r to ConduitT r m i o, which would preclude a 0 or   instance.The result value from upstream and downstream are allowed to differ between upstream and downstream. In other words, we would need the type signature here to look like ;ConduitT a b m r -> ConduitT b c m r -> ConduitT a c m r.iDue to leftovers, we do not have a left identity in Conduit. This can be achieved with the underlying Pipe9 datatype, but this is not generally recommended. See  $https://stackoverflow.com/a/15263700.jconduitjThe 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 y. Since 0.4.0kconduitA synonym for m for backwards compatibility. Since 0.4.0lconduitA synonym for m for backwards compatibility. Since 0.4.0mconduitDeprecated fusion operator. Since 0.4.0nconduitOWait 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.0oconduitSend a value downstream to the next component to consume. If the downstream component terminates, this call will never return control. Since 0.5.0pconduitBSend a monadic value downstream for the next component to consume.qconduitnProvide 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.rconduit*Run a pipeline until processing completes. Since 1.2.1sconduitBracket 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.0tconduitWWait 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.0uconduitTransform the monad that a ConduitT 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 Since 0.4.0vconduit/Apply a function to all the output values of a ConduitT.This mimics the behavior of - for a K and G? in pre-0.4 days. It can also be simulated by fusing with the map conduit from Data.Conduit.List. Since 0.4.1wconduitSame as v", but use a function that returns Maybe values. Since 0.5.0xconduit.Apply a function to all the input values of a ConduitT. Since 0.5.0yconduit9The 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.0zconduit#Continue processing after usage of $$+. Since 0.5.0{conduitSame as $$++ and  connectResume#, but doesn't include the updated SealedConduitT.NOTEt In previous versions, this would cause finalizers to run. Since version 1.3.0, there are no finalizers in conduit. Since 0.5.0|conduit Left fusion for a sealed source. Since 1.0.16}conduit*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 1. Since 1.0.13~conduit#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.13conduit9The 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.17conduit#Continue processing after usage of  . Connect a MC to a sink and return the output of the sink together with a new M. Since 1.0.17conduitSame as =$$++#, but doesn't include the updated SealedConduitT.NOTEt In previous versions, this would cause finalizers to run. Since version 1.3.0, there are no finalizers in conduit. Since 1.0.17conduit&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.17conduit Fuse two ConduitTas together, and provide the return value of both. Note that this will force the entire upstream ConduitTQ to be run to produce the result value, even if the downstream terminates early. Since 1.1.5conduitLike (, 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.4conduitSame as fuseBoth3, but ignore the return value from the downstream Conduit+. Same caveats of forced consumption apply. Since 1.1.5conduitFRun a pure pipeline until processing completes, i.e. a pipeline with Identity, as the base monad. This is equivalient to runIdentity . runConduit.conduit-Run a pipeline which acquires resources with  ResourceT, and then run the  ResourceT% transformer. This is equivalent to runResourceT . runConduit.2conduiteconduit finalizericonduitupstreamconduit downstreamoconduit output valuesconduit-computation to run first ("acquire resource")conduit,computation to run last ("release resource")conduitcomputation to run in-betweenxconduitmap initial input to new inputconduit&map new leftovers to initial leftoversM;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ i2j0k1l2m2y0z0{0|1000 Trustworthy3CQVGdconduitjThis is the same as stream fusion's Step. Constructors are renamed to avoid confusion with conduit names. TrustworthyNQVH^++None %FNQTVMconduitStreaming versions of /Data.Conduit.Combinators.Internal.initReplicateconduitStreaming versions of ,Data.Conduit.Combinators.Internal.initRepeat3conduitUtility functionconduitmaximum allowed sizeNone3<QVNB;<=>?@ABCDEFGHIJKLMORSXYZ[\abdefghijklmnopqrstuvwxyz{|}~BOKGILighjklmnopqrsZ[\JHXYtuvwxdefMRSyz{|baDEFABC}>?@~;<=SafePs !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmryz{|}~b !"#$%&'()*+,-56789./01342:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmryz{|}~NoneQVl<conduitWrap the base monad in 4 Since 1.2.12conduitRun 4 in the base monad Since 1.2.12conduit Catch an error in the base monad Since 1.2.12conduitRun 5 in the base monad Since 1.1.0conduit$Catch an exception in the base monad Since 1.1.0conduitWrap the base monad in 6 Since 1.0.11conduitRun 6 in the base monad Since 1.0.11conduitWrap the base monad in 7 Since 1.0.11conduitRun 7 in the base monad Since 1.0.11conduitWrap the base monad in 8 Since 1.0.11conduitRun 8 in the base monad Since 1.0.11conduit Evaluate 8 in the base monad Since 1.0.11conduitExecute 8 in the base monad Since 1.0.11conduitWrap the base monad in 9 Since 1.0.11conduitRun 9 in the base monad Since 1.0.11conduit Evaluate 9 in the base monad Since 1.0.11conduitExecute 9 in the base monad Since 1.0.11conduitWrap the base monad in : Since 1.0.11conduitRun : in the base monad Since 1.0.11conduitExecute : in the base monad Since 1.0.11conduitWrap the base monad in ; Since 1.0.11conduitRun ; in the base monad Since 1.0.11conduitExecute ; in the base monad Since 1.0.11conduitWrap the base monad in < Since 1.0.11conduitRun < in the base monad Since 1.0.11conduit Evaluate < in the base monad Since 1.0.11conduitExecute < in the base monad Since 1.0.11conduitWrap the base monad in = Since 1.0.11conduitRun = in the base monad Since 1.0.11conduit Evaluate = in the base monad Since 1.0.11conduitExecute = in the base monad Since 1.0.11 TrustworthyQVS>conduit$Generate a source from a seed value.Subject to fusion Since 0.4.2conduit$Generate a source from a seed value.Subject to fusion Since 0.4.2? conduit8Generate a source from a seed value with a return value.Subject to fusion conduit8Generate a source from a seed value with a return value.Subject to fusion@conduitA monadic unfold.Subject to fusion Since 1.1.2conduitA monadic unfold.Subject to fusion Since 1.1.2A conduitA monadic unfoldEither.Subject to fusion conduitA monadic unfoldEither.Subject to fusionBconduitYield the values from the list.Subject to fusionconduitYield the values from the list.Subject to fusionCconduit8Enumerate 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.2conduit8Enumerate 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.2Dconduit?Produces an infinite stream of repeated applications of f to x.Subject to fusionconduit?Produces an infinite stream of repeated applications of f to x.Subject to fusionEconduit3Replicate a single value the given number of times.Subject to fusion Since 1.2.0conduit3Replicate a single value the given number of times.Subject to fusion Since 1.2.0Fconduit4Replicate a monadic value the given number of times.Subject to fusion Since 1.2.0conduit4Replicate a monadic value the given number of times.Subject to fusion Since 1.2.0GconduitA strict left fold.Subject to fusion Since 0.3.0conduitA strict left fold.Subject to fusion Since 0.3.0HconduitA monadic strict left fold.Subject to fusion Since 0.3.0conduitA monadic strict left fold.Subject to fusion Since 0.3.0 conduitA monoidal strict left fold.Subject to fusion Since 0.5.3 conduit'A monoidal strict left fold in a Monad. Since 1.0.8Iconduit-Apply the action to all values in the stream.Subject to fusion Since 0.3.0 conduit-Apply the action to all values in the stream.Subject to fusion Since 0.3.0Jconduit^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 conduit^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.0KconduitTake 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 conduitTake 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.0Lconduit2Take a single value from the stream, if available.Subject to fusion Since 0.3.0conduit2Take a single value from the stream, if available.Subject to fusion Since 0.3.0conduitkLook at the next value in the stream, if available. This function will not change the state of the stream. Since 0.3.0Mconduit1Apply a transformation to all values in a stream.Subject to fusion Since 0.3.0conduit1Apply a transformation to all values in a stream.Subject to fusion Since 0.3.0Nconduit9Apply 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.0conduit9Apply 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.0Oconduit1Apply 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.6conduit1Apply 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.6PconduitYApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1conduitYApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1QconduitaApply a monadic transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1conduitaApply a monadic transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1Rconduit Filter the Just& values from a stream, discarding the Nothing values.Subject to fusion Since 0.5.1conduit Filter the Just& values from a stream, discarding the Nothing values.Subject to fusion Since 0.5.1SconduitGeneralization of . It puts all values from T into stream.Subject to fusion Since 1.0.6conduitGeneralization of . It puts all values from T into stream.Subject to fusion Since 1.0.6UconduitSApply a transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0conduitSApply a transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0Vconduit[Apply a monadic transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0conduit[Apply a monadic transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0Wconduit with a strict accumulator.Subject to fusion Since 0.3.0conduit with a strict accumulator.Subject to fusion Since 0.3.0conduitDeprecated synonym for mapAccum Since 1.0.6conduitDeprecated synonym for  mapAccumM Since 1.0.6Xconduit 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.1conduit 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.1YconduitMonadic .Subject to fusion Since 1.1.1conduitMonadic .Subject to fusion Since 1.1.1conduit Analog of Z for lists.Subject to fusion Since 1.1.1conduitMonadic scanl.Subject to fusion Since 1.1.1[conduit with a strict accumulator.Subject to fusion Since 0.3.0 conduit with a strict accumulator.Subject to fusion Since 0.3.0\conduitGeneralization 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.6!conduitGeneralization 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.6]conduitMonadic variant of !.Subject to fusion Since 1.0.6"conduitMonadic variant of !.Subject to fusion Since 1.0.6^conduitjConsume 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#conduitjConsume 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$conduit^Group a stream into chunks of a given size. The last chunk may contain fewer than n elements.Subject to fusion Since 1.2.9_conduit1Grouping input according to an equality function.Subject to fusion Since 0.3.0%conduit1Grouping input according to an equality function.Subject to fusion Since 0.3.0`conduit& 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&conduit& 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.7aconduitbEnsure 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.0'conduitbEnsure 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.0bconduit9Keep only values in the stream passing a given predicate.Subject to fusion Since 0.3.0(conduit9Keep only values in the stream passing a given predicate.Subject to fusion Since 0.3.0cconduitVIgnore the remainder of values in the source. Particularly useful when combined with '.Subject to fusion Since 0.3.0)conduitVIgnore the remainder of values in the source. Particularly useful when combined with '.Subject to fusion Since 0.3.0dconduitWA source that outputs no values. Note that this is just a type-restricted synonym for e.Subject to fusion Since 0.3.0*conduitWA source that outputs no values. Note that this is just a type-restricted synonym for e.Subject to fusion Since 0.3.0+conduitRun a Pipej repeatedly, and output its result value downstream. Stops when no more input is available from upstream. Since 0.5.0+conduitPipe to run repeatedly.      !"#$%&'()*+.*   #)  !$%&'(" + None|fghi Safe1Vjconduitsymlink to filekconduitsymlink to a directory lmnopqrjkst None &'<>?QV,conduitA buffer allocation strategy (buf0, nextBuf)F specifies the initial buffer to use and how to compute a new buffer nextBuf minSize buf with at least size minSize from a filled buffer buf. The double nesting of the IO? monad helps to ensure that the reference to the filled buffer bufZ is lost as soon as possible, but the new buffer doesn't have to be allocated too early.uconduit A buffer Buffer fpbuf p0 op ope4 describes a buffer with the underlying byte array  fpbuf..ope, the currently written slice p0..op and the free space op..ope.vconduitProvides a series of  ByteString4s until empty, at which point it provides an empty  ByteString.wconduit0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion-conduit0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion.conduit&Generate a producer from a seed value.Subject to fusion/conduit8Enumerate from a value to a final value, inclusive, via x.,This is generally more efficient than using Prelude's  enumFromTo and combining with  sourceList5 since this avoids any intermediate data structures.Subject to fusion0conduit?Produces an infinite stream of repeated applications of f to x.Subject to fusion1conduitBProduce an infinite stream consisting entirely of the given value.Subject to fusion2conduitBProduce a finite stream consisting of n copies of the given value.Subject to fusion3conduit?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see y.Subject to fusionzconduitARepeatedly run the given action and yield all values it produces.Subject to fusion4conduitARepeatedly run the given action and yield all values it produces.Subject to fusion{conduithRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion5conduithRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion6conduit7Perform the given action n times, yielding each result.Subject to fusion7conduit-Stream the contents of a file as binary data.8conduitStream 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.9conduitSame as  sourceHandler, but instead of allocating a new buffer for each incoming chunk of data, reuses the same buffer. Therefore, the  ByteStringUs yielded by this function are not referentially transparent between two different yields.3This function will be slightly more efficient than  sourceHandle by avoiding allocations and reducing garbage collections, but should only be used if you can guarantee that you do not reuse a  ByteString. (or any slice thereof) between two calls to await.:conduitAn alternative to 8". Instead of taking a pre-opened |#, it takes an action that opens a |[ (in read mode), so that it can open it only when needed and close it as soon as possible.;conduitSame as 7@. The alternate name is a holdover from an older version, when 7' was more polymorphic than it is today.<conduit sourceHandle applied to stdin.Subject to fusion=conduit+Stream all incoming data to the given file.>conduitCautious version of =. The idea here is to stream the values to a temporary file in the same directory of the destination file, and only on successfully writing the entire file, moves it atomically to the destination path.In the event of an exception occurring, the temporary file will be deleted and no move will be made. If the application shuts down without running exception handling (such as machine failure or a SIGKILL), the temporary file will remain and the destination file will be untouched.?conduitLike >, but uses the with pattern instead of  MonadResource.}conduit<Helper function for Cautious functions above, do not export!~conduit<Helper function for Cautious functions above, do not export!@conduitStream data into a temporary file in the given directory with the given filename pattern, and return the temporary filename. The temporary file will be automatically deleted when exiting the active  ResourceT block, if it still exists.AconduitSame as @U, but will use the default temp file directory for the system as the first argument.Bconduit&Stream all incoming data to the given | . Note that this function does not flush and will not close the Handle when processing completes.CconduitNStream incoming builders, executing them directly on the buffer of the given |. Note that this function does not automatically close the Handle" when processing completes. Pass  to flush the buffer.DconduitStream incoming Flushes, executing them on  IO.Handle Note that this function does not automatically close the Handle when processing completesEconduitAn alternative to B". 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.FconduitLike +, but provides a source to read bytes from.GconduitLike (, but provides a sink to write bytes to.HconduitSame as G, but lets you use a .IconduitFStream the contents of the given directory, without traversing deeply.This function will return allL of the contents of the directory, whether they be files, directories, etc.}Note that the generated filepaths will be the complete path, not just the filename. In other words, if you have a directory foo containing files bar and baz, and you use sourceDirectory on foo, the results will be foo/bar and foo/baz.Jconduit2Deeply stream the contents of the given directory.This works the same as sourceDirectory, but will not return directories at all. This function also takes an extra parameter to indicate whether symlinks will be followed.Kconduit0Ignore a certain number of values in the stream.WNote: since this function doesn't produce anything, you probably want to use it with (2) instead of directly plugging it into a pipeline:3runConduit $ yieldMany [1..5] .| drop 2 .| sinkList[]5runConduit $ yieldMany [1..5] .| (drop 2 >> sinkList)[3,4,5]Lconduit8Drop a certain number of elements from a chunked stream.LNote: you likely want to use it with monadic composition. See the docs for K.Mconduit0Drop all values which match the given predicate.LNote: you likely want to use it with monadic composition. See the docs for K.NconduitHDrop all elements in the chunked stream which match the given predicate.LNote: you likely want to use it with monadic composition. See the docs for K.Oconduit,Monoidally combine all values in the stream.Subject to fusionPconduit6Monoidally combine all elements in the chunked stream.Subject to fusionQconduitA strict left fold.Subject to fusionRconduit'A strict left fold on a chunked stream.Subject to fusionSconduitDApply the provided mapping function and monoidal combine all values.Subject to fusionTconduit\Apply the provided mapping function and monoidal combine all elements of the chunked stream.Subject to fusionconduit4A strict left fold with no starting value. Returns  when the stream is empty.Subject to fusionUconduit4A strict left fold with no starting value. Returns  when the stream is empty.Subject to fusionconduitIA strict left fold on a chunked stream, with no starting value. Returns  when the stream is empty.Subject to fusionconduit0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusionVconduit0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusionWconduit:Check that all elements in the chunked stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusionconduit9Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusionXconduit9Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusionYconduitCCheck that at least one element in the chunked stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusionZconduit"Are all values in the stream True?6Consumption stops once the first False is encountered.Subject to fusion[conduit,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered.Subject to fusion\conduit"Are any values in the stream True?5Consumption stops once the first True is encountered.Subject to fusion]conduit,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.Subject to fusion^conduit$ly combine all values in the stream._conduit6Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusion`conduitBAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusionaconduit5Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusionbconduitAAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusionconduit|Consume all incoming strict chunks into a lazy sequence. Note that the entirety of the sequence will be resident at memory.`This can be used to consume a stream of strict ByteStrings into a lazy ByteString, for example.Subject to fusioncconduit|Consume all incoming strict chunks into a lazy sequence. Note that the entirety of the sequence will be resident at memory.`This can be used to consume a stream of strict ByteStrings into a lazy ByteString, for example.Subject to fusiondconduitjConsume all values from the stream and return as a list. Note that this will pull all values into memory.Subject to fusionconduitZSink incoming values into a vector, growing the vector as necessary to fit more elements.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusioneconduitZSink incoming values into a vector, growing the vector as necessary to fit more elements.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusionconduit2Sink incoming values into a vector, up until size maxSizeI. Subsequent values will be left in the stream. If there are less than maxSize values present, returns a Vector of smaller size.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusionfconduit2Sink incoming values into a vector, up until size maxSizeI. Subsequent values will be left in the stream. If there are less than maxSize values present, returns a Vector of smaller size.<Note that using this function is more memory efficient than sinkList and then converting to a Vector., as it avoids intermediate list constructors.Subject to fusionconduitSame as  sinkBuilderA, but afterwards convert the builder to its lazy representation.:Alternatively, this could be considered an alternative to sinkLazy", with the following differences:bThis function will allow multiple input types, not just the strict version of the lazy structure..Some buffer copying may occur in this version.Subject to fusiongconduitSame as  sinkBuilderA, but afterwards convert the builder to its lazy representation.:Alternatively, this could be considered an alternative to sinkLazy", with the following differences:bThis function will allow multiple input types, not just the strict version of the lazy structure..Some buffer copying may occur in this version.Subject to fusionhconduit7Consume and discard all remaining values in the stream.Subject to fusioniconduitSame as await, but discards any leading  values.jconduit2Take a single value from the stream, if available.kconduitSame as jD, but returns a default value if none are available from the stream.lconduit+Get the next element in the chunked stream.mconduit7View the next value in the stream without consuming it.nconduitAView the next element in the chunked stream without consuming it.conduit2Retrieve the last value in the stream, if present.Subject to fusionoconduit2Retrieve the last value in the stream, if present.Subject to fusionpconduitSame as oD, but returns a default value if none are available from the stream.conduit<Retrieve the last element in the chunked stream, if present.Subject to fusionqconduit<Retrieve the last element in the chunked stream, if present.Subject to fusionrconduit(Count how many values are in the stream.Subject to fusionsconduit2Count how many elements are in the chunked stream.Subject to fusiontconduit=Count how many values in the stream pass the given predicate.Subject to fusionuconduitGCount how many elements in the chunked stream pass the given predicate.Subject to fusionvconduit0Get the largest value in the stream, if present.Subject to fusionwconduit:Get the largest element in the chunked stream, if present.Subject to fusionxconduit1Get the smallest value in the stream, if present.Subject to fusionyconduit;Get the smallest element in the chunked stream, if present.Subject to fusionzconduit*True if there are no values in the stream.)This function does not modify the stream.{conduit4True if there are no elements in the chunked stream.aThis function may remove empty leading chunks from the stream, but otherwise will not modify it.|conduit(Get the sum of all values in the stream.Subject to fusion}conduit2Get the sum of all elements in the chunked stream.Subject to fusion~conduit,Get the product of all values in the stream.Subject to fusionconduit6Get the product of all elements in the chunked stream.Subject to fusionconduitFind the first matching value.Subject to fusionconduitFind the first matching value.Subject to fusionconduit-Apply the action to all values in the stream.Note: if you want to pass the values instead of  consuming them, use  instead.Subject to fusionconduit7Apply the action to all elements in the chunked stream.Note: the same caveat as with @ applies. If you don't want to consume the values, you can use : iterM (omapM_ f)Subject to fusionconduitA monadic strict left fold.Subject to fusionconduit/A monadic strict left fold on a chunked stream.Subject to fusionconduitLApply the provided monadic mapping function and monoidal combine all values.Subject to fusionconduiteApply the provided monadic mapping function and monoidal combine all elements in the chunked stream.Subject to fusionconduit= specialized to  to help with type inference.conduit$Print all incoming values to stdout.Subject to fusionconduit sinkHandle applied to stdout.Subject to fusionconduit sinkHandle applied to stderr.Subject to fusionconduit1Apply a transformation to all values in a stream.Subject to fusionconduit;Apply a transformation to all elements in a chunked stream.Subject to fusionconduitGApply a monomorphic transformation to all elements in a chunked stream.Unlike mapE, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor.Subject to fusionconduitApply the function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.Subject to fusionconduitApply the function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.Subject to fusionconduitApply the function to each element in the chunked stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.Subject to fusionconduit+Stream up to n number of values downstream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see .Subject to fusionconduitAStream up to n number of elements downstream in a chunked stream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see .conduit<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with .conduitRStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with .conduitFConsume precisely the given number of values and feed them downstream. This function is in contrast to , which will only consume up to the given number of values, and will terminate early if downstream terminates early. This function will discard any additional values in the stream if they are unconsumed.+Note that this function takes a downstream ConduitTW as a parameter, as opposed to working with normal fusion. For more information, see  <http://www.yesodweb.com/blog/2013/10/core-flaw-pipes-conduit3, the section titled "pipes and conduit: isolate".conduitSame as , but for chunked streams.conduitFFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusionconduitFFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusionconduit9Keep only values in the stream passing a given predicate.Subject to fusionconduitCKeep only elements in the chunked stream passing a given predicate.Subject to fusionconduit$Map values as long as the result is Just.conduitBreak up a stream of values into vectors of size n. The final vector may be smaller than n if the total number of values is not a strict multiple of n. No empty vectors will be yielded.conduit Analog of Z for lists.Subject to fusionconduit Analog of Z for lists.Subject to fusionconduitJ with a break condition dependent on a strict accumulator. Equivalently,  as long as the result is Righta. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.Subject to fusionconduitJ with a break condition dependent on a strict accumulator. Equivalently,  as long as the result is Righta. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.Subject to fusionconduit with an accumulator.Subject to fusionconduit=Insert the given value between each two values in the stream.Subject to fusionconduit=Insert the given value between each two values in the stream.Subject to fusionconduitUSliding window of values 1,2,3,4,5 with window size 2 gives [1,2],[2,3],[3,4],[4,5]1Best used with structures that support O(1) snoc.Subject to fusionconduitUSliding window of values 1,2,3,4,5 with window size 2 gives [1,2],[2,3],[3,4],[4,5]1Best used with structures that support O(1) snoc.Subject to fusionconduitSplit input into chunk of size  chunkSize)The last element may be smaller than the  chunkSize (see also ( which will not yield this last element)conduitSplit input into chunk of size  chunkSize[If the input does not split into chunks exactly, the remainder will be leftover (see also )conduit9Apply 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 fusionconduitCApply a monadic transformation to all elements in a chunked stream.Subject to fusionconduitOApply a monadic monomorphic transformation to all elements in a chunked stream.Unlike mapME, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor.Subject to fusionconduitApply the monadic function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.4Generalizes concatMapM, mapMaybeM, and mapFoldableM.Subject to fusionconduitApply the monadic function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.4Generalizes concatMapM, mapMaybeM, and mapFoldableM.Subject to fusionconduitAKeep only values in the stream passing a given monadic predicate.Subject to fusionconduitAKeep only values in the stream passing a given monadic predicate.Subject to fusionconduitKKeep only elements in the chunked stream passing a given monadic predicate.Subject to fusionconduit1Apply 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 fusionconduit Analog of Z for lists, monadic.Subject to fusionconduit Analog of Z for lists, monadic.Subject to fusionconduitMonadic .Subject to fusionconduitMonadic .Subject to fusionconduit with an accumulator.Subject to fusionconduit Encode a stream of text as UTF8.Subject to fusionconduit'Decode a stream of binary data as UTF8.conduitlDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character.conduit(Stream in the entirety of a single line.Like  takeExactly^, this will consume the entirety of the line regardless of the behavior of the inner Conduit.conduitSame as $, but operates on ASCII/binary data.conduitAStream in the chunked input until an element matches a predicate.Like  takeExactly`, this will consume the entirety of the prefix regardless of the behavior of the inner Conduit.conduit=Insert a newline character after each incoming chunk of data.Subject to fusionconduitSame as $, but operates on ASCII/binary data.Subject to fusionconduitSplit a stream of arbitrarily-chunked data, based on a predicate on elements. Elements that satisfy the predicate will cause chunks to be split, and aren't included in these output chunks. Note that, if you have unknown or untrusted input, this function is unsafeX, since it would allow an attacker to form chunks of massive length and exhaust memory.conduitSplit a stream of arbitrarily-chunked data, based on a predicate on elements. Elements that satisfy the predicate will cause chunks to be split, and aren't included in these output chunks. Note that, if you have unknown or untrusted input, this function is unsafeX, since it would allow an attacker to form chunks of massive length and exhaust memory.conduitConvert a stream of arbitrarily-chunked textual data into a stream of data where each chunk represents a single line. Note that, if you have unknown or untrusted input, this function is unsafeW, since it would allow an attacker to form lines of massive length and exhaust memory.Subject to fusionconduitSame as , but for ASCII/binary data.Subject to fusionconduitMIncrementally execute builders and pass on the filled chunks as bytestrings.conduitSame as ', but input and output are wrapped in D.conduitIncrementally execute builders on the given buffer and pass on the filled chunks as bytestrings. Note that, if the given buffer is too small for the execution of a build step, a larger one will be allocated.WARNING: This conduit yields bytestrings that are NOT referentially transparent. Their content will be overwritten as soon as control is returned from the inner sink!conduitpA conduit that incrementally executes builders and passes on the filled chunks as bytestrings to an inner sink.<INV: All bytestrings passed to the inner sink are non-empty.conduitconduitConvert the buffer to a bytestring. This operation is unsafe in the sense that created bytestring shares the underlying byte array with the buffer. Hence, depending on the later use of this buffer (e.g., if it gets reset and filled again) referential transparency may be lost.conduit0Convert a buffer to a non-empty bytestring. See : for the explanation of why this operation may be unsafe.conduit Update the end of slice pointer.conduit,The size of the written slice in the buffer.conduit8Safe default: allocate new buffers of default chunk sizeconduitThe simplest buffer allocation strategy: whenever a buffer is requested, allocate a new one that is big enough for the next build step to execute.NOTE that this allocation strategy may spill quite some memory upon direct insertion of a bytestring by the builder. Thats no problem for garbage collection, but it may lead to unreasonably high memory consumption in special circumstances.conduitAn unsafe, but possibly more efficient buffer allocation strategy: reuse the buffer, if it is big enough for the next build step to execute.conduit7The size of the whole byte array underlying the buffer.conduitallocBuffer size allocates a new buffer of size size.conduitnResets the beginning of the next slice and the next free byte such that the whole buffer can be filled again.conduitGenerally speaking, yielding values from inside a Conduit requires some allocation for constructors. This can introduce an overhead, similar to the overhead needed to represent a list of values instead of a vector. This overhead is even more severe when talking about unboxed values.!This combinator allows you to overcome this overhead, and efficiently fill up vectors. It takes two parameters. The first is the size of each mutable vector to be allocated. The second is a function. The function takes an argument which will yield the next value into a mutable vector.Under the surface, this function uses a number of tricks to get high performance. For more information on both usage and implementation, please see: Lhttps://www.fpcomplete.com/user/snoyberg/library-documentation/vectorbuilderconduitConsume a source with a strict accumulator, in a way piecewise defined by a controlling stream. The latter will be evaluated until it terminates./let f a s = liftM (:s) $ mapC (*a) =$ CL.take aLreverse $ runIdentity $ yieldMany [0..3] $$ mapAccumS f [] (yieldMany [1..])$[[],[1],[4,6],[12,15,18]] :: [[Int]]conduitfRun a consuming conduit repeatedly, only stopping when there is no more data available from upstream.conduitfRun a consuming conduit repeatedly, only stopping when there is no more data available from upstream.In contrast to j, this function will ignore empty chunks of data. So for example, if a stream of data contains an empty  ByteStringJ, it is still treated as empty, and the consuming function is not called.@conduittemp directoryconduitfilename patternAconduitfilename patternJconduitFollow directory symlinksconduitRoot directoryconduitmaximum allowed sizefconduitmaximum allowed sizeconduitmaximum allowed sizeconduitsize,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-./01234567;89:<FIJKLMNOPQURSTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=>@ABEGH?CD,None &'<>?QVkconduit&Generate a producer from a seed value.conduit8Enumerate 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.conduit?Produces an infinite stream of repeated applications of f to x.conduitBProduce an infinite stream consisting entirely of the given value.conduitBProduce a finite stream consisting of n copies of the given value.conduitARepeatedly run the given action and yield all values it produces.conduithRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.conduit7Perform the given action n times, yielding each result.conduit sourceHandle applied to stdin.conduit0Ignore a certain number of values in the stream.WNote: since this function doesn't produce anything, you probably want to use it with (2) instead of directly plugging it into a pipeline:4runConduit $ yieldMany [1..5] .| dropC 2 .| sinkList[]6runConduit $ yieldMany [1..5] .| (dropC 2 >> sinkList)[3,4,5]conduit8Drop a certain number of elements from a chunked stream.LNote: you likely want to use it with monadic composition. See the docs for .conduit0Drop all values which match the given predicate.LNote: you likely want to use it with monadic composition. See the docs for .conduitHDrop all elements in the chunked stream which match the given predicate.LNote: you likely want to use it with monadic composition. See the docs for .conduit,Monoidally combine all values in the stream.conduit6Monoidally combine all elements in the chunked stream.conduitA strict left fold.conduit'A strict left fold on a chunked stream.conduitDApply the provided mapping function and monoidal combine all values.conduit\Apply the provided mapping function and monoidal combine all elements of the chunked stream.conduit0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.conduit:Check that all elements in the chunked stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.conduit9Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.conduitCCheck that at least one element in the chunked stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.conduit"Are all values in the stream True?6Consumption stops once the first False is encountered.conduit,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered.conduit"Are any values in the stream True?5Consumption stops once the first True is encountered.conduit,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.conduit$ly combine all values in the stream.conduit6Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found.conduitBAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.conduit5Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found.conduitAAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.conduit2Take a single value from the stream, if available.conduitSame as D, but returns a default value if none are available from the stream.conduit+Get the next element in the chunked stream.conduit7View the next value in the stream without consuming it.conduitAView the next element in the chunked stream without consuming it.conduit2Retrieve the last value in the stream, if present.conduitSame as D, but returns a default value if none are available from the stream.conduit<Retrieve the last element in the chunked stream, if present.conduit(Count how many values are in the stream.conduit2Count how many elements are in the chunked stream.conduit=Count how many values in the stream pass the given predicate.conduitGCount how many elements in the chunked stream pass the given predicate.conduit0Get the largest value in the stream, if present.conduit:Get the largest element in the chunked stream, if present.conduit1Get the smallest value in the stream, if present.conduit;Get the smallest element in the chunked stream, if present.conduit*True if there are no values in the stream.)This function does not modify the stream.conduit4True if there are no elements in the chunked stream.aThis function may remove empty leading chunks from the stream, but otherwise will not modify it.conduit(Get the sum of all values in the stream.conduit2Get the sum of all elements in the chunked stream.conduit,Get the product of all values in the stream.conduit6Get the product of all elements in the chunked stream.conduitFind the first matching value.conduit-Apply the action to all values in the stream.Note: if you want to pass the values instead of  consuming them, use iterM instead.conduit7Apply the action to all elements in the chunked stream.Note: the same caveat as with @ applies. If you don't want to consume the values, you can use iterM: iterM (omapM_ f)conduitA monadic strict left fold.conduit/A monadic strict left fold on a chunked stream.conduitLApply the provided monadic mapping function and monoidal combine all values.conduiteApply the provided monadic mapping function and monoidal combine all elements in the chunked stream.conduit$Print all incoming values to stdout.conduit sinkHandle applied to stdout.conduit sinkHandle applied to stderr.conduit1Apply a transformation to all values in a stream.conduit;Apply a transformation to all elements in a chunked stream.conduitGApply a monomorphic transformation to all elements in a chunked stream.Unlike mapE, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor.conduitApply the function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.conduitApply the function to each element in the chunked stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.1Generalizes concatMap, mapMaybe, and mapFoldable.conduit+Stream up to n number of values downstream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see  takeExactly.conduitAStream up to n number of elements downstream in a chunked stream.bNote that, if downstream terminates early, not all values will be consumed. If you want to force exactly1 the given number of values to be consumed, see  takeExactlyE. conduit<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with take. conduitRStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with takeE. conduitFConsume precisely the given number of values and feed them downstream. This function is in contrast to take, which will only consume up to the given number of values, and will terminate early if downstream terminates early. This function will discard any additional values in the stream if they are unconsumed.+Note that this function takes a downstream ConduitTW as a parameter, as opposed to working with normal fusion. For more information, see  <http://www.yesodweb.com/blog/2013/10/core-flaw-pipes-conduit3, the section titled "pipes and conduit: isolate". conduitSame as  takeExactly, but for chunked streams. conduitFFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.conduit9Keep only values in the stream passing a given predicate.conduitCKeep only elements in the chunked stream passing a given predicate.conduit$Map values as long as the result is Just.conduitBreak up a stream of values into vectors of size n. The final vector may be smaller than n if the total number of values is not a strict multiple of n. No empty vectors will be yielded.conduit Analog of  for lists.conduitJ with a break condition dependent on a strict accumulator. Equivalently,  as long as the result is Righta. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.conduit concatMap with an accumulator.conduit=Insert the given value between each two values in the stream.conduitUSliding window of values 1,2,3,4,5 with window size 2 gives [1,2],[2,3],[3,4],[4,5]1Best used with structures that support O(1) snoc.conduitSplit input into chunk of size  chunkSize)The last element may be smaller than the  chunkSize (see also chunksOfExactlyE( which will not yield this last element)conduitSplit input into chunk of size  chunkSize[If the input does not split into chunks exactly, the remainder will be leftover (see also  chunksOfE)conduit9Apply 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 mapM_.conduitCApply a monadic transformation to all elements in a chunked stream.conduitOApply a monadic monomorphic transformation to all elements in a chunked stream.Unlike mapME, this will work on types like  ByteString and Text which are  MonoFunctor but not Functor.conduitApply the monadic function to each value in the stream, resulting in a foldable value (e.g., a list). Then yield each of the individual values in that foldable value separately.4Generalizes concatMapM, mapMaybeM, and mapFoldableM.conduitAKeep only values in the stream passing a given monadic predicate.conduitKKeep only elements in the chunked stream passing a given monadic predicate.conduit1Apply 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) conduit Analog of  for lists, monadic.!conduitMonadic ."conduit concatMapM with an accumulator.#conduit Encode a stream of text as UTF8.$conduit'Decode a stream of binary data as UTF8.%conduitlDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character.&conduit(Stream in the entirety of a single line.Like  takeExactly^, this will consume the entirety of the line regardless of the behavior of the inner Conduit.'conduitSame as line$, but operates on ASCII/binary data.(conduit=Insert a newline character after each incoming chunk of data.)conduitSame as unlines$, but operates on ASCII/binary data.*conduitConvert a stream of arbitrarily-chunked textual data into a stream of data where each chunk represents a single line. Note that, if you have unknown"untrusted input, this function is ^unsafe/, since it would allow an attacker to form lines of massive length and exhaust memory.+conduitSame as linesUnbounded, but for ASCII/binary data.,conduitGenerally speaking, yielding values from inside a Conduit requires some allocation for constructors. This can introduce an overhead, similar to the overhead needed to represent a list of values instead of a vector. This overhead is even more severe when talking about unboxed values.!This combinator allows you to overcome this overhead, and efficiently fill up vectors. It takes two parameters. The first is the size of each mutable vector to be allocated. The second is a function. The function takes an argument which will yield the next value into a mutable vector.Under the surface, this function uses a number of tricks to get high performance. For more information on both usage and implementation, please see: Lhttps://www.fpcomplete.com/user/snoyberg/library-documentation/vectorbuilderconduitmaximum allowed size,conduitsize,-3789:;=>?@ABCDEFGHIJcdefghi      !"#$%&'()*+,None<  ;<=>?@ABCDEFGHIJKLMORSXYZ[\abdefghijklmnopqrstuvwxyz{|}~,-3789:;=>?@ABCDEFGHIJcdefghi      !"#$%&'()*+,-37;89:FIJcdefghi=>@ABEGH?CD      !"#$%&'()*+,,    !" !#$%&$%'()*()+(),-./-01-02-34-35-67-68-69-6:-6;-6<-6=>?@>?A>?B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b b c d d e f f g h i h  j k l m n o o p p q r s t u v w x y z { | } ~  I L M N O K U V W X      ZY !"#$%&'()*+,-./0123456789 : ;  Y  <  = > ?  @ A B C D E F G H I J K L M N O P Q R S  T U V  W X Y  Z [ \ ] ^ _ ` a b c d e f g h i j k l m 7 n  o p  q r s t u v w x y z { | } ~                   '        & 6      )     !   (   " *  .                           !"#$% &'$() *+$,-$./$01$21$34$54$67$879:;< =>?$@ABCDEFGHIJKL M N O P Q RSTUSVWSVX Y Z [ \ ] ^ _ ` abcdef  gh i jklm no p  q r s t udvw  x yz{           | } ~      $conduit-1.3.1-CUrYVncIeVuL1pX5cKvVj8 Data.ConduitConduitData.Conduit.InternalData.Conduit.Internal.Fusion!Data.Conduit.Internal.List.StreamData.Conduit.Combinators.StreamData.Conduit.LiftData.Conduit.ListData.Conduit.CombinatorsData.Conduit.Internal.PipeData.Conduit.Internal.ConduitData.Streaming.FileReadData.Streaming.FilesystemData.ByteString.Builder.ExtraflushBBBuilder$Data.Conduit.Combinators.UnqualifiedPreludescanlCLmapAccumbase Data.VoidVoidControl.Monad.IO.ClassliftIOMonadIOData.Functor.Identity runIdentityIdentity(exceptions-0.10.0-CxZF6fjB5Z4GsPqBR1nkMsControl.Monad.CatchthrowM MonadThrowtransformers-0.5.5.0Control.Monad.Trans.Classlift MonadTrans(primitive-0.6.4.0-39Pwmm1zkQX6bM7xFUT3JcControl.Monad.Primitive primitive PrimState PrimMonad&resourcet-1.2.2-3dYg1kucG1iAqIvb1IMQZEControl.Monad.Trans.Resource runResourceT Data.Acquire withAcquireallocateAcquire%Control.Monad.Trans.Resource.Internal MonadResource ResourceTData.Acquire.Internal mkAcquireType mkAcquireReleaseException ReleaseNormal ReleaseEarly ReleaseTypeAcquire,unliftio-core-0.1.2.0-900TPot3SR34dceIcVaslSControl.Monad.IO.Unlift MonadUnliftIO withRunInIO askUnliftIOPipe HaveOutput NeedInputDonePipeMLeftoverawaitawaitE awaitForeveryieldyieldMleftoverbracketPidPpipepipeLrunPipeinjectLeftovers transPipe mapOutputmapOutputMaybemapInput enumFromTo sourceList withUpstream>+><+<catchPhandlePtryPgeneralizeUpstream ZipConduit getZipConduitZipSink getZipSink ZipSource getZipSourceFlushChunkConsumerSinkProducerSourceConduitMSealedConduitTConduitT unConduitT sealConduitTunsealConduitT connectResume sourceToPipe sinkToPipe conduitToPipe toProducer toConsumercatchChandleCtryCzipSinks zipSources zipSourcesApp zipConduitAppfuseReturnLeftovers fuseLeftoversconnectResumeConduit mergeSourcepassthroughSink sourceToListconnectfuse.|$$$==$=$= runConduit$$+$$++$$+-$=+sequenceSources sequenceSinks=$$+=$$++=$$+-sequenceConduitsfuseBoth fuseBothMaybe fuseUpstreamrunConduitPure runConduitResStreamConsumer StreamSinkStreamProducer StreamSource StreamConduitStreamConduitTConduitWithStreamStreamStepEmitSkipStopunstream streamConduit streamSourcestreamSourcePure $fFunctorStep GroupByStateGBStartGBLoopGBDoneunfoldS unfoldEitherSunfoldMSunfoldEitherMS sourceListS enumFromToSenumFromToS_intiterateS replicateS replicateMSfoldSfoldMSmapM_SdropStakeSheadSmapSmapMSiterMS mapMaybeS mapMaybeMS catMaybesSconcatS concatMapS concatMapMSconcatMapAccumS mapAccumS mapAccumMSconcatMapAccumMS mapFoldableS mapFoldableMSconsumeSgroupByS groupOn1S groupBy1SisolateSfilterS sinkNullS sourceNullS yieldManySrepeatMS repeatWhileMSfoldl1SallSanyS sinkLazyS sinkVectorS sinkVectorNSsinkLazyBuilderSlastSlastESfindSscanlSscanlMSmapAccumWhileSmapAccumWhileMS intersperseSslidingWindowSfilterMSsplitOnUnboundedESinitReplicateS initRepeatSexceptC runExceptC catchExceptC runCatchC catchCatchCmaybeC runMaybeCreaderC runReaderCstateLC runStateLC evalStateLC execStateLCstateC runStateC evalStateC execStateCwriterLC runWriterLC execWriterLCwriterC runWriterC execWriterCrwsLCrunRWSLC evalRWSLC execRWSLCrwsCrunRWSCevalRWSCexecRWSCunfold unfoldEitherunfoldM unfoldEitherMiterate replicate replicateMfoldfoldMfoldMapfoldMapMmapM_droptakeheadpeekmapmapMiterMmapMaybe mapMaybeM catMaybesconcat concatMap concatMapMconcatMapAccumscanlM mapAccumMscanscanMconcatMapAccumM mapFoldable mapFoldableMconsumechunksOfgroupBygroupOn1isolatefiltersinkNull sourceNullsequenceBufferAllocStrategy yieldManyrepeat sourceLazyrepeatM repeatWhileM sourceFile sourceHandlesourceHandleUnsafesourceIOHandle sourceFileBSstdinsinkFilesinkFileCautiouswithSinkFileCautious sinkTempFilesinkSystemTempFile sinkHandlesinkHandleBuildersinkHandleFlush sinkIOHandlewithSourceFile withSinkFilewithSinkFileBuildersourceDirectorysourceDirectoryDeepdropE dropWhile dropWhileEfoldEfoldlfoldlEfoldMapEfoldl1allallEanyanyEandandEororEasumelemelemEnotElemnotElemEsinkLazysinkList sinkVector sinkVectorNsinkLazyBuilder awaitNonNullheadDefheadEpeekElastlastDeflastElengthlengthElengthIf lengthIfEmaximummaximumEminimumminimumEnullnullEsumsumEproductproductEfindmapM_EfoldME foldMapME sinkFileBSprintstdoutstderrmapEomapE concatMapEtakeE takeWhile takeWhileE takeExactly takeExactlyEfilterEmapWhile conduitVector mapAccumWhile intersperse slidingWindow chunksOfEchunksOfExactlyEmapMEomapMEfilterMfilterMEmapAccumWhileM encodeUtf8 decodeUtf8decodeUtf8Lenientline lineAsciitakeExactlyUntilEunlines unlinesAsciisplitOnUnboundedElinesUnboundedlinesUnboundedAsciibuilderToByteStringbuilderToByteStringFlushunsafeBuilderToByteStringbuilderToByteStringWithbuilderToByteStringWithFlushallNewBuffersStrategyreuseBufferStrategy vectorBuilder peekForever peekForeverEunfoldC enumFromToCiterateCrepeatC replicateCrepeatMC repeatWhileMC replicateMCstdinCdropCdropCE dropWhileC dropWhileCEfoldCfoldCEfoldlCfoldlCEfoldMapC foldMapCEallCallCEanyCanyCEandCandCEorCorCEasumCelemCelemCEnotElemC notElemCEheadCheadDefCheadCEpeekCpeekCElastClastDefClastCElengthClengthCE lengthIfC lengthIfCEmaximumC maximumCEminimumC minimumCEnullCnullCEsumCsumCEproductC productCEfindCmapM_CmapM_CEfoldMCfoldMCE foldMapMC foldMapMCEprintCstdoutCstderrCmapCmapCEomapCE concatMapC concatMapCEtakeCtakeCE takeWhileC takeWhileCE takeExactlyC takeExactlyCEconcatCfilterCfilterCE mapWhileCscanlCmapAccumWhileCconcatMapAccumC intersperseCslidingWindowC chunksOfCEchunksOfExactlyCEmapMCmapMCEomapMCE concatMapMCfilterMC filterMCEiterMCscanlMCmapAccumWhileMCconcatMapAccumMC encodeUtf8C decodeUtf8CdecodeUtf8LenientClineC lineAsciiCunlinesC unlinesAsciiClinesUnboundedClinesUnboundedAsciiCvectorBuilderCGHC.Basefmapbuild ApplicativeMonad Data.Foldable sequence_$fMonadFailConduitTfmapSControl.Monad.Trans.ExceptExceptTControl.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.Strict unfoldEitherCunfoldMCunfoldEitherMC sourceListC mapMaybeC mapMaybeMC catMaybesCFoldable mapAccumC mapAccumMCGHC.List mapFoldableC mapFoldableMCconsumeCgroupByC groupOn1CisolateC sinkNullC sourceNullCmempty ReadHandleopenFile closeFile readChunk FTFileSymFTDirectorySym unix-2.7.2.2System.Posix.Directory openDirStreamSystem.Posix.Directory.CommoncloseDirStream DirStreamFileTypeFTFile FTDirectoryFTOther readDirStream getFileTypeBuffer BuilderPopper yieldManyCGHC.Enumsucc/mono-traversable-1.0.9.0-CDYyjyfQ77H1PpHiQpjtIkData.SequencestoChunksGHC.IO.Handle.TypesHandlecautiousAcquirecautiousCleanup System.IOwithBinaryFile>>foldl1CNothingfoldl1E Alternative sinkLazyC sinkVectorC sinkVectorNCsinkLazyBuilderCData.MonoTraversableonulllastECbytestring-0.10.8.2Data.ByteString.Internal ByteStringsplitOnUnboundedECunsafeFreezeBufferunsafeFreezeNonEmptyBufferupdateEndOfSlice sliceSizedefaultStrategy bufferSize allocBuffer reuseBuffer