m$      !"#$%&'()*+,-./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;<=>?FNQTVbXThe 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.0UProvide new output to be sent downstream. This constructor has two fields: the next Pipe! to be used 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.09Send a single output value downstream. If the downstream Pipe terminates, this Pipe will terminate as well. Since 0.5.0iProvide 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. 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  The identity Pipe. Since 0.5.0!<Compose a left and right pipe together into a complete pipe. Since 0.5.0"Same 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.0%Transform 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&/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.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 Pipe. Since 0.5.0*Convert a list into a source. Since 0.3.0%The equivalent of GHC.Exts.build for Pipe. Since 0.4.2+zReturns a tuple of the upstream and downstream results. Note that this will force consumption of the entire input stream. Since 0.5.0,Fuse 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.0-Same as ,), but reverse the order of the arguments. Since 0.5.0.See catchC for more details. Since 1.0.11/ The same as  flip catchP. Since 1.0.110See tryC for more details. Since 1.0.111+Generalize the upstream return value for a Pipe from unit to any type. Since 1.1.5 output value-computation to run first ("acquire resource"),computation to run last ("release resource")computation to run in-between(map initial input to new input&map new leftovers to initial leftovers !"#$%&'()*+,-./01,9 -9   Trustworthy3;<=>?FNQTV%U;2Provides 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.175A wrapper for defining an & instance for @8s which allows to combine sinks together, generalizing T. 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 2d, 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.138A wrapper for defining an & instance for B:s which allows to combine sources together, generalizing U>. 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>lConsumes a stream of input values and produces a stream of output values, without producing a final result. Since 0.5.0?uA 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.0@]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.0AYA 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.0B]Provides a stream of output values, without consuming any input or producing a final result. Since 0.5.0CSame as F, for backwards compatD<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.F{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.0K 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.0O Generalize a B to a A. Since 1.0.0P Generalize a @ to a ?. Since 1.0.0QECatch 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.11R The same as  flip catchC. Since 1.0.11S A version of try0 for use within a pipeline. See the comments in catchC for more details. Since 1.0.11TWCombines two sinks. The new sink will complete when both input sinks have completed.Any leftovers are discarded. Since 0.4.1UbCombines two sources. The new source will stop producing once either source has been exhausted. Since 1.0.13VbCombines two sources. The new source will stop producing once either source has been exhausted. Since 1.0.13W Since 1.0.17XSame as normal fusion (e.g. =$=V), except instead of discarding leftovers from the downstream component, return them. Since 1.0.17Y Similar to fuseReturnLeftoversW, but use the provided function to convert downstream leftovers to upstream leftovers. Since 1.0.17Z Connect a >B to a sink and return the output of the sink together with a new >. Since 1.0.17[Merge a Source into a Conduit[. The new conduit will stop processing once either source or upstream have been exhausted.\Turn 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.0] 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.6^Equivalent to using i and ` together. Since 1.2.3_Named function synonym for `.Equivalent to ` and dM. However, the latter is deprecated and will be removed in a future version. 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.Equivalent to _ and dL, however the latter is deprecated and will be removed in a future version.ajThe 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 p. Since 0.4.0bA synonym for d for backwards compatibility. Since 0.4.0cA synonym for d for backwards compatibility. Since 0.4.0dDeprecated fusion operator. Since 0.4.0eOWait 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.0fSend a value downstream to the next component to consume. If the downstream component terminates, this call will never return control. Since 0.5.0gBSend a monadic value downstream for the next component to consume.hnProvide 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.i*Run a pipeline until processing completes. Since 1.2.1jBracket 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.0kWWait 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.0lTransform 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.0m/Apply a function to all the output values of a ConduitT.This mimics the behavior of $ for a B and >? in pre-0.4 days. It can also be simulated by fusing with the map conduit from Data.Conduit.List. Since 0.4.1nSame as m", but use a function that returns Maybe values. Since 0.5.0o.Apply a function to all the input values of a ConduitT. Since 0.5.0p9The 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.0q#Continue processing after usage of $$+. Since 0.5.0rSame 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.0s Left fusion for a sealed source. Since 1.0.16t*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.13u#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.13v9The 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.17w#Continue processing after usage of v . Connect a DC to a sink and return the output of the sink together with a new D. Since 1.0.17xSame 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.17y&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.17z 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.5{Like z(, 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.4|Same as fuseBoth3, but ignore the return value from the downstream Conduit+. Same caveats of forced consumption apply. Since 1.1.5\ finalizer`upstream downstreamf output valuej-computation to run first ("acquire resource"),computation to run last ("release resource")computation to run in-betweenomap initial input to new input&map new leftovers to initial leftoversK23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|23456789:;<=DEFGH `2a0b1c2d2p0q0r0s1v0w0x0 Trustworthy3CQV)jThis is the same as stream fusion's Step. Constructors are renamed to avoid confusion with conduit names.}~~}( TrustworthyNQV*++None %FNQTV/Streaming versions of /Data.Conduit.Combinators.Internal.initReplicateStreaming versions of ,Data.Conduit.Combinators.Internal.initRepeat)Utility functionmaximum allowed size*+,-./012345678None3<QV6+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.B23456789:;<=>?@ABCDFIJOPQRSXY[\]^_`abcdefghijklmnopqrstuvwxyz{|BFB>@C`^_abcdz{|efghijQRSA?OPklmno[\]DIJpqrsvwxYX;<=89:t567u234ySafe8sq !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdipqrstuvwxyz{|}~j !"#$,-./0%&'(*+)1FGHCBA@?>;<=89:567234DEIJekfghi_^KZYXpqrsvwxabcd`LMNOPjQRSlmnoTUVW[\]z{|tuyNoneQVP*Wrap the base monad in 9 Since 1.2.12Run 9 in the base monad Since 1.2.12 Catch an error in the base monad Since 1.2.12Run : 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 A Since 1.0.11Run A in the base monad Since 1.0.11 Evaluate A in the base monad Since 1.0.11Execute A in the base monad Since 1.0.11Wrap the base monad in B Since 1.0.11Run B in the base monad Since 1.0.11 Evaluate B in the base monad Since 1.0.11Execute B in the base monad Since 1.0.11 TrustworthyQVSC$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.2D 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 fusionEA monadic unfold.Subject to fusion Since 1.1.2A monadic unfold.Subject to fusion Since 1.1.2F A monadic unfoldEither.Subject to fusion A monadic unfoldEither.Subject to fusionGYield the values from the list.Subject to fusionYield the values from the list.Subject to fusionH8Enumerate 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.2I?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 fusionJ3Replicate 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.0K4Replicate 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.0LA strict left fold.Subject to fusion Since 0.3.0A strict left fold.Subject to fusion Since 0.3.0MA 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.8N-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.0O^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.0PTake 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.0Q2Take 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.0R1Apply 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.0S9Apply 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.0T1Apply 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 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.6UYApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1 YApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1VaApply a monadic 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.1W 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.1XGeneralization of  . It puts all values from Y into stream.Subject to fusion Since 1.0.6 Generalization of  . It puts all values from Y into stream.Subject to fusion Since 1.0.6ZSApply 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.1^Monadic .Subject to fusion Since 1.1.1Monadic .Subject to fusion Since 1.1.1 Analog of _ for lists.Subject to fusion Since 1.1.1Monadic scanl.Subject to fusion Since 1.1.1` with a strict accumulator.Subject to fusion Since 0.3.0 with a strict accumulator.Subject to fusion Since 0.3.0aGeneralization 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.6bMonadic variant of .Subject to fusion Since 1.0.6Monadic variant of .Subject to fusion Since 1.0.6cjConsume 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.9d1Grouping 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.0e 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.7fbEnsure 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.0g9Keep 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.0hVIgnore the remainder of values in the source. Particularly useful when combined with .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.0iWA source that outputs no values. Note that this is just a type-restricted synonym for j.Subject to fusion Since 0.3.0!WA source that outputs no values. Note that this is just a type-restricted synonym for j.Subject to fusion Since 0.3.0"Run a Pipej repeatedly, and output its result value downstream. Stops when no more input is available from upstream. Since 0.5.0"Pipe to run repeatedly.      !".!      " Noneklmnko Safe1Vpsymlink to fileqsymlink to a directory rstuvwxpqyzuvpwqx None &'<>?QV#A 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.{ 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.|Provides a series of  ByteString4s until empty, at which point it provides an empty  ByteString.}0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion$0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion%&Generate a producer from a seed value.Subject to fusion&8Enumerate from a value to a final value, inclusive, via ~.,This is generally more efficient than using Prelude's  enumFromTo and combining with  sourceList5 since this avoids any intermediate data structures.Subject to fusion'?Produces an infinite stream of repeated applications of f to x.Subject to fusion(BProduce an infinite stream consisting entirely of the given value.Subject to fusion)BProduce a finite stream consisting of n copies of the given value.Subject to fusion*?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see .Subject to fusionARepeatedly run the given action and yield all values it produces.Subject to fusion+ARepeatedly run the given action and yield all values it produces.Subject to fusionhRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion,hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion-7Perform the given action n times, yielding each result.Subject to fusion.-Stream the contents of a file as binary data./Stream the contents of a / as binary data. Note that this function will not automatically close the Handle: when processing completes, since it did not acquire the Handle in the first place.0Same 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.1An alternative to /". 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.2. specialized to  to help with type inference.3 sourceHandle applied to stdin.Subject to fusion4+Stream all incoming data to the given file.5Cautious version of 4. 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.6Like 5, but uses the with pattern instead of  MonadResource.<Helper function for Cautious functions above, do not export!<Helper function for Cautious functions above, do not export!7Stream 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.8Same as 7U, but will use the default temp file directory for the system as the first argument.9&Stream all incoming data to the given  . Note that this function does not flush and will not close the Handle when processing completes.:NStream 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.;Stream incoming Flushes, executing them on  IO.Handle Note that this function does not automatically close the Handle when processing completes<An alternative to 9". 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.=Like +, but provides a source to read bytes from.>Like (, but provides a sink to write bytes to.?Same as >, but lets you use a .@FStream 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.A2Deeply 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.B0Ignore 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]C8Drop a certain number of elements from a chunked stream.LNote: you likely want to use it with monadic composition. See the docs for B.D0Drop all values which match the given predicate.LNote: you likely want to use it with monadic composition. See the docs for B.EHDrop 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 B.F,Monoidally combine all values in the stream.Subject to fusionG6Monoidally combine all elements in the chunked stream.Subject to fusionHA strict left fold.Subject to fusionI'A strict left fold on a chunked stream.Subject to fusionJDApply the provided mapping function and monoidal combine all values.Subject to fusionK\Apply the provided mapping function and monoidal combine all elements of the chunked stream.Subject to fusion4A strict left fold with no starting value. Returns  when the stream is empty.Subject to fusionL4A strict left fold with no starting value. Returns  when the stream is empty.Subject to fusionIA strict left fold on a chunked stream, with no starting value. Returns  when the stream is empty.Subject to fusion0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusionM0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusionN: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 fusion9Check 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 fusionO9Check 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 fusionPCCheck 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 fusionQ"Are all values in the stream True?6Consumption stops once the first False is encountered.Subject to fusionR,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered.Subject to fusionS"Are any values in the stream True?5Consumption stops once the first True is encountered.Subject to fusionT,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.Subject to fusionU$ly combine all values in the stream.V6Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusionWBAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusionX5Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusionYAAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusion|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 fusionZ|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 fusion[jConsume all values from the stream and return as a list. Note that this will pull all values into memory.Subject to fusionZSink 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 fusion\ZSink 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 fusion2Sink 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 fusion]2Sink 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 fusionSame 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 fusion^Same 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 fusion_7Consume and discard all remaining values in the stream.Subject to fusion`Same as await, but discards any leading  values.a2Take a single value from the stream, if available.bSame as aD, but returns a default value if none are available from the stream.c+Get the next element in the chunked stream.d7View the next value in the stream without consuming it.eAView the next element in the chunked stream without consuming it.2Retrieve the last value in the stream, if present.Subject to fusionf2Retrieve the last value in the stream, if present.Subject to fusiongSame as fD, but returns a default value if none are available from the stream.<Retrieve the last element in the chunked stream, if present.Subject to fusionh<Retrieve the last element in the chunked stream, if present.Subject to fusioni(Count how many values are in the stream.Subject to fusionj2Count how many elements are in the chunked stream.Subject to fusionk=Count how many values in the stream pass the given predicate.Subject to fusionlGCount how many elements in the chunked stream pass the given predicate.Subject to fusionm0Get the largest value in the stream, if present.Subject to fusionn:Get the largest element in the chunked stream, if present.Subject to fusiono1Get the smallest value in the stream, if present.Subject to fusionp;Get the smallest element in the chunked stream, if present.Subject to fusionq*True if there are no values in the stream.)This function does not modify the stream.r4True 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.s(Get the sum of all values in the stream.Subject to fusiont2Get the sum of all elements in the chunked stream.Subject to fusionu,Get the product of all values in the stream.Subject to fusionv6Get the product of all elements in the chunked stream.Subject to fusionFind the first matching value.Subject to fusionwFind the first matching value.Subject to fusionx-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 fusiony7Apply the action to all elements in the chunked stream.Note: the same caveat as with x@ applies. If you don't want to consume the values, you can use : iterM (omapM_ f)Subject to fusionzA monadic strict left fold.Subject to fusion{/A monadic strict left fold on a chunked stream.Subject to fusion|LApply the provided monadic mapping function and monoidal combine all values.Subject to fusion}eApply the provided monadic mapping function and monoidal combine all elements in the chunked stream.Subject to fusion~4 specialized to  to help with type inference.$Print all incoming values to stdout.Subject to fusion sinkHandle applied to stdout.Subject to fusion sinkHandle applied to stderr.Subject to fusion1Apply a transformation to all values in a stream.Subject to fusion;Apply a transformation to all elements in a chunked stream.Subject to fusionGApply 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 fusionApply 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 fusionApply 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 fusionApply 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 fusion+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 fusionAStream 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 .<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with .RStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with .FConsume 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".Same as , but for chunked streams.FFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusionFFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusion9Keep only values in the stream passing a given predicate.Subject to fusionCKeep only elements in the chunked stream passing a given predicate.Subject to fusion$Map values as long as the result is Just.Break 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. Analog of _ for lists.Subject to fusion Analog of _ for lists.Subject to fusionJ 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 fusionJ 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 fusion with an accumulator.Subject to fusion=Insert the given value between each two values in the stream.Subject to fusion=Insert the given value between each two values in the stream.Subject to fusionUSliding 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 fusionUSliding 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 fusionSplit input into chunk of size  chunkSize)The last element may be smaller than the  chunkSize (see also ( which will not yield this last element)Split input into chunk of size  chunkSize[If the input does not split into chunks exactly, the remainder will be leftover (see also )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 x.Subject to fusionCApply a monadic transformation to all elements in a chunked stream.Subject to fusionOApply 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 fusionApply 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 fusionApply 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 fusionAKeep only values in the stream passing a given monadic predicate.Subject to fusionAKeep only values in the stream passing a given monadic predicate.Subject to fusionKKeep only elements in the chunked stream passing a given monadic predicate.Subject to fusion1Apply 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 Analog of _ for lists, monadic.Subject to fusion Analog of _ for lists, monadic.Subject to fusionMonadic .Subject to fusionMonadic .Subject to fusion with an accumulator.Subject to fusion Encode a stream of text as UTF8.Subject to fusion'Decode a stream of binary data as UTF8.lDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character.(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.Same as $, but operates on ASCII/binary data.AStream 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.=Insert a newline character after each incoming chunk of data.Subject to fusionSame as $, but operates on ASCII/binary data.Subject to fusionSplit 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.Split 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.Convert 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 fusionSame as , but for ASCII/binary data.Subject to fusionMIncrementally execute builders and pass on the filled chunks as bytestrings.Same as ', but input and output are wrapped in ;.Incrementally 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!pA 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.Convert 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.0Convert a buffer to a non-empty bytestring. See : for the explanation of why this operation may be unsafe. Update the end of slice pointer.,The size of the written slice in the buffer.8Safe default: allocate new buffers of default chunk sizeThe 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.An unsafe, but possibly more efficient buffer allocation strategy: reuse the buffer, if it is big enough for the next build step to execute.7The size of the whole byte array underlying the buffer.allocBuffer size allocates a new buffer of size size.nResets the beginning of the next slice and the next free byte such that the whole buffer can be filled again.Generally 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/vectorbuilderConsume 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]]fRun a consuming conduit repeatedly, only stopping when there is no more data available from upstream.fRun 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.7temp directoryfilename pattern8filename patternAFollow directory symlinksRoot directorymaximum allowed size]maximum allowed sizemaximum allowed sizesize#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$%&'()*+,-.2/013=@ABCDEFGHLIJKMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}4578~9<>?6:;#{None &'<>?QVdOk&Generate a producer from a seed value.8Enumerate 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.?Produces an infinite stream of repeated applications of f to x.BProduce an infinite stream consisting entirely of the given value.BProduce a finite stream consisting of n copies of the given value.ARepeatedly run the given action and yield all values it produces.hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.7Perform the given action n times, yielding each result. sourceHandle applied to stdin.0Ignore 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]8Drop a certain number of elements from a chunked stream.LNote: you likely want to use it with monadic composition. See the docs for .0Drop all values which match the given predicate.LNote: you likely want to use it with monadic composition. See the docs for .HDrop 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 .,Monoidally combine all values in the stream.6Monoidally combine all elements in the chunked stream.A strict left fold.'A strict left fold on a chunked stream.DApply the provided mapping function and monoidal combine all values.\Apply the provided mapping function and monoidal combine all elements of the chunked stream.0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.:Check that all elements in the chunked stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.9Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop.CCheck 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."Are all values in the stream True?6Consumption stops once the first False is encountered.,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered."Are any values in the stream True?5Consumption stops once the first True is encountered.,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.$ly combine all values in the stream.6Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found.BAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.5Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found.AAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.2Take a single value from the stream, if available.Same as D, but returns a default value if none are available from the stream.+Get the next element in the chunked stream.7View the next value in the stream without consuming it.AView the next element in the chunked stream without consuming it.2Retrieve the last value in the stream, if present.Same as D, but returns a default value if none are available from the stream.<Retrieve the last element in the chunked stream, if present.(Count how many values are in the stream.2Count how many elements are in the chunked stream.=Count how many values in the stream pass the given predicate.GCount how many elements in the chunked stream pass the given predicate.0Get the largest value in the stream, if present.:Get the largest element in the chunked stream, if present.1Get the smallest value in the stream, if present.;Get the smallest element in the chunked stream, if present.*True if there are no values in the stream.)This function does not modify the stream.4True 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.(Get the sum of all values in the stream.2Get the sum of all elements in the chunked stream.,Get the product of all values in the stream.6Get the product of all elements in the chunked stream.Find the first matching value.-Apply the action to all values in the stream.Note: if you want to pass the values instead of  consuming them, use iterM instead.7Apply 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)A monadic strict left fold./A monadic strict left fold on a chunked stream.LApply the provided monadic mapping function and monoidal combine all values.eApply the provided monadic mapping function and monoidal combine all elements in the chunked stream.$Print all incoming values to stdout. sinkHandle applied to stdout. sinkHandle applied to stderr.1Apply a transformation to all values in a stream.;Apply a transformation to all elements in a chunked stream.GApply 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.Apply 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.Apply 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.+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.AStream 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.<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with take.RStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with takeE.FConsume 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".Same as  takeExactly, but for chunked streams.FFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.9Keep only values in the stream passing a given predicate.CKeep only elements in the chunked stream passing a given predicate.$Map values as long as the result is Just.Break 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.  Analog of  for lists. J 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.  concatMap with an accumulator. =Insert the given value between each two values in the stream. USliding 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.Split 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)Split input into chunk of size  chunkSize[If the input does not split into chunks exactly, the remainder will be leftover (see also  chunksOfE)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 mapM_.CApply a monadic transformation to all elements in a chunked stream.OApply 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.Apply 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.AKeep only values in the stream passing a given monadic predicate.KKeep only elements in the chunked stream passing a given monadic predicate.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) Analog of  for lists, monadic.Monadic  . concatMapM with an accumulator. Encode a stream of text as UTF8.'Decode a stream of binary data as UTF8.lDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character.(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.Same as line$, but operates on ASCII/binary data.=Insert a newline character after each incoming chunk of data. Same as unlines$, but operates on ASCII/binary data.!Convert 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."Same as linesUnbounded, but for ASCII/binary data.#Generally 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/vectorbuildermaximum allowed size#size#$*./012456789:;<=>?@AZ[\]^_`~      !"#None<f  23456789:;<=>?@ABCDFIJOPQRSXY[\]^_`abcdefghijklmnopqrstuvwxyz{|#$*./012456789:;<=>?@AZ[\]^_`~      !"#$*.2/01=@AZ[\]^_`4578~9<>?6:;      !"##    !" !#$%&$%'()*()+(),-./-01-02345346347 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 W X Y Y Z [ [ \ ] ^ ]  _ ` a b c d d e 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 @ J K L M ON      !"#$%&'()*+,-. / 0  N  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  { | } ~              +                    #                            !"#$%&'($)* +,$-.$/0$12$32$45$65$78$98:;<=>?@ABCD EFGHIJKLM N O P Q N R STUVTWXTWY Z [ \ ] ^ _ ` a bcdefg  hijkl m nopq rs t  u v w x yez{  |            } ~          `---------&conduit-1.3.0.1-8rrm21b5QZ01KchIwqcMiH 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-7TCTIMybnidG16W1buN3ECControl.Monad.CatchthrowM MonadThrowtransformers-0.5.2.0Control.Monad.Trans.Classlift MonadTrans(primitive-0.6.2.0-EI3NK1Xfv9zEcRtyXK2EwZControl.Monad.Primitive primitive PrimState PrimMonad%resourcet-1.2.0-EmE0XiFmOdT92bcrcvwuCControl.Monad.Trans.Resource runResourceT%Control.Monad.Trans.Resource.Internal MonadResource ResourceT,unliftio-core-0.1.1.0-3wrHy3Ijr0BBoYMyh4oX3gControl.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 fuseUpstreamStreamConsumer 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 initRepeatSrunConduitPure runConduitResexceptC 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 Applicative Data.Foldable sequence_fmapS SplitState SplitDone SplitNoSepSlidingWindowState SWInitial SWSliding SWEarlyExitIntersperseState IFirstValue IGotValue IEmitValue ScanState ScanEnded ScanContinuesControl.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.8.1-6EWdxe3PQoV4mIHxn2pmI4Data.SequencestoChunksGHC.IO.Handle.TypesHandlebytestring-0.10.8.2Data.ByteString.Internal ByteStringcautiousAcquirecautiousCleanup System.IOwithBinaryFile>>foldl1CNothingfoldl1E Alternative sinkLazyC sinkVectorC sinkVectorNCsinkLazyBuilderCData.MonoTraversableonulllastECsplitOnUnboundedECunsafeFreezeBufferunsafeFreezeNonEmptyBufferupdateEndOfSlice sliceSizedefaultStrategy bufferSize allocBuffer reuseBufferS Data.Acquire withAcquireallocateAcquireData.Acquire.Internal mkAcquireType mkAcquire ReleaseType ReleaseEarly ReleaseNormalReleaseExceptionAcquire