h&gnW      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                         Trustworthy j conduitThe 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 (o), 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.0conduitProvide new output to be sent downstream. This constructor has two fields: the next Pipe! to be used and the output value.conduitRequest more input from upstream. The first field takes a new input value and provides a new Pipe. 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.!conduitReturn 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'conduitProvide a single piece of leftover input to be consumed by the next pipe in the current monadic binding.Note: it is highly encouraged to only return leftover values from input already consumed from upstream. Since 0.5.0(conduit Split a pipe into head and tail. Since 1.3.3)conduitSplit a pipe into head and tail or return its result if it is done. Since 1.3.3*conduitBracket a pipe computation between allocation and release of a resource. We guarantee, via the  MonadResource 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 [ConduitT i Void m r] -> ConduitT i Void 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 =, 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.13CconduitA wrapper for defining an  instance for M: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.13Fconduit1Provide 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.0IconduitConsumes a stream of input values and produces a stream of output values, without producing a final result. Since 0.5.0JconduitA 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.0KconduitConsumes 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.0LconduitA 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.0MconduitProvides a stream of output values, without consuming any input or producing a final result. Since 0.5.0NconduitSame as Q, for backwards compatOconduit ConduitT b c m r -> ConduitT a c m r.Due 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.nconduitThe connect operator, which pulls data from a source and pushes to a sink. If you would like to keep the Source open to be used for other operations, use the connect-and-resume operator ~. Since 0.4.0oconduitA synonym for q for backwards compatibility. Since 0.4.0pconduitA synonym for q for backwards compatibility. Since 0.4.0qconduitDeprecated fusion operator. Since 0.4.0rconduitWait 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.0sconduitSend a value downstream to the next component to consume. If the downstream component terminates, this call will never return control. Since 0.5.0tconduitSend a monadic value downstream for the next component to consume.uconduitProvide a single piece of leftover input to be consumed by the next component in the current monadic binding.Note: it is highly encouraged to only return leftover values from input already consumed from upstream.vconduit*Run a pipeline until processing completes. Since 1.2.1wconduitBracket 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.0xconduitWait for input forever, calling the given inner component for each piece of new input.This function is provided as a convenience for the common pattern of awaiting input, checking if it's Just and then looping. Since 0.5.0yconduitTransform 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: https://github.com/snoyberg/conduit/wiki/Dealing-with-monad-transformers Since 0.4.0zconduit/Apply a function to all the output values of a ConduitT.This mimics the behavior of  for a M and I? in pre-0.4 days. It can also be simulated by fusing with the map conduit from Data.Conduit.List. Since 0.4.1{conduitSame as z", but use a function that returns Maybe values. Since 0.5.0|conduit.Apply a function to all the input values of a ConduitT. Since 0.5.0}conduit4Apply a monadic action to all the input values of a ConduitT. Since 1.3.2~conduit9The connect-and-resume operator. This does not close the Source:, but instead returns it to be used again. This allows a Source 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.0conduit#Continue processing after usage of $$+. Since 0.5.0conduitSame as $$++ and  connectResume#, but doesn't include the updated SealedConduitT.NOTE In previous versions, this would cause finalizers to run. Since version 1.3.0, there are no finalizers in conduit. Since 0.5.0conduit Left fusion for a sealed source. Since 1.0.16conduit*Coalesce all values yielded by all of the Sources.Implemented on top of  ZipSource 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.13conduit#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 Conduit 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 O to a sink and return the output of the sink together with a new O. Since 1.0.17conduitSame as =$$++#, but doesn't include the updated SealedConduitT.NOTE 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 ConduitTs together, and provide the return value of both. Note that this will force the entire upstream ConduitT 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.One 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.5conduitRun 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.conduitgconduit finalizermconduitupstreamconduit downstreamsconduit output valuewconduit-computation to run first ("acquire resource")conduit,computation to run last ("release resource")conduitcomputation to run in-between|conduitmap initial input to new inputconduit&map new leftovers to initial leftovers}conduitmap initial input to new inputconduit&map new leftovers to initial leftovers=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ m2n0o1p2q2~0001000 Trustworthy8`conduitThis is the same as stream fusion's Step. Constructors are renamed to avoid confusion with conduit names. Trustworthy`++ Safe-Inferred (b_conduitStreaming versions of /Data.Conduit.Combinators.Internal.initReplicateconduitStreaming versions of ,Data.Conduit.Combinators.Internal.initRepeatconduitUtility functionconduitmaximum allowed size Safe-Inferred8b=>?@ABCDEFGHIJKLMNOQTUZ[\]^cdfghilmnopqrstuvwxyz{|}~QMIKNmilnopqrstuvw\]^LJZ[xyz{|}fghOTU~dcFGHCDE@AB=>?Safec! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghilmnopqv~ !"#$%&'()*+,-./789:;0123564<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghilmnopqv~ Safe-InferredlgconduitWrap the base monad in  Since 1.2.12conduitRun  in the base monad Since 1.2.12conduit Catch an error in the base monad Since 1.2.12conduitRun  in the base monad Since 1.1.0conduit$Catch an exception in the base monad Since 1.1.0conduitWrap the base monad in  Since 1.0.11conduitRun  in the base monad Since 1.0.11conduitWrap the base monad in  Since 1.0.11conduitRun  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.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 Trustworthyconduit$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 fusionconduitA monadic unfold.Subject to fusion Since 1.1.2conduitA monadic unfold.Subject to fusion Since 1.1.2 conduitA monadic unfoldEither.Subject to fusion conduitA monadic unfoldEither.Subject to fusionconduitSplit a pure conduit into head and tail. This is equivalent to runIdentity . unconsM.Note that you have to T it first. Since 1.3.3conduitSplit a pure conduit into head and tail or return its result if it is done. This is equivalent to runIdentity . unconsEitherM.Note that you have to T it first. Since 1.3.3conduitYield the values from the list.Subject to fusionconduitYield the values from the list.Subject to fusionconduit8Enumerate 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.2conduit?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 fusionconduit3Replicate 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.0conduit4Replicate 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.0conduitA strict left fold.Subject to fusion Since 0.3.0conduitA strict left fold.Subject to fusion Since 0.3.0conduitA monadic strict left fold.Subject to fusion Since 0.3.0conduitA monadic strict left fold.Subject to fusion Since 0.3.0conduitA monoidal strict left fold.Subject to fusion Since 0.5.3conduit'A monoidal strict left fold in a Monad. Since 1.0.8conduit-Apply the action to all values in the stream.Subject to fusion Since 0.3.0conduit-Apply the action to all values in the stream.Subject to fusion Since 0.3.0conduitIgnore a certain number of values in the stream. This function is semantically equivalent to: drop i = take i >> return () However, drop is more efficient as it does not need to hold values in memory.Subject to fusion Since 0.3.0conduitIgnore a certain number of values in the stream. This function is semantically equivalent to: drop i = take i >> return () However, drop is more efficient as it does not need to hold values in memory.Subject to fusion Since 0.3.0conduitTake 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.0conduitTake 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.0conduit2Take 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.0conduitLook at the next value in the stream, if available. This function will not change the state of the stream. Since 0.3.0conduit1Apply 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.0conduit9Apply a monadic transformation to all values in a stream.If 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.If 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.0conduit1Apply a monadic action on all values in a stream.This Conduit 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 Conduit 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.6conduitApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1conduitApply a transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1conduitApply a monadic transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1conduitApply a monadic transformation that may fail to all values in a stream, discarding the failures.Subject to fusion Since 0.5.1conduit 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.1conduitGeneralization of . It puts all values from  into stream.Subject to fusion Since 1.0.6conduitGeneralization of . It puts all values from  into stream.Subject to fusion Since 1.0.6conduitApply a transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0conduitApply a transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0conduitApply a monadic transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0conduitApply a monadic transformation to all values in a stream, concatenating the output values.Subject to fusion Since 0.3.0conduit 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.6conduit 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.1conduitMonadic .Subject to fusion Since 1.1.1conduitMonadic .Subject to fusion Since 1.1.1conduit Analog of  for lists.Subject to fusion Since 1.1.1conduitMonadic scanl.Subject to fusion Since 1.1.1conduit with a strict accumulator.Subject to fusion Since 0.3.0conduit with a strict accumulator.Subject to fusion Since 0.3.0conduitGeneralization of  and . It applies function to all values in a stream and send values inside resulting Foldable downstream.Subject to fusion Since 1.0.6conduitGeneralization of  and . It applies function to all values in a stream and send values inside resulting Foldable downstream.Subject to fusion Since 1.0.6conduitMonadic variant of .Subject to fusion Since 1.0.6conduitMonadic variant of .Subject to fusion Since 1.0.6conduitConsume 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.0conduitConsume 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.0conduitGroup a stream into chunks of a given size. The last chunk may contain fewer than n elements.Subject to fusion Since 1.2.9conduit1Grouping input according to an equality function.Subject to fusion Since 0.3.0conduit1Grouping input according to an equality function.Subject to fusion Since 0.3.0conduit 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.7conduit 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.7conduitLike , but returning a  structure.conduitEnsure 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.: src $$ do x <- isolate count =$ do x <- someSink sinkNull return x someOtherSink ...Subject to fusion Since 0.3.0conduitEnsure 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.: src $$ do x <- isolate count =$ do x <- someSink sinkNull return x someOtherSink ...Subject to fusion Since 0.3.0conduit9Keep only values in the stream passing a given predicate.Subject to fusion Since 0.3.0conduit9Keep only values in the stream passing a given predicate.Subject to fusion Since 0.3.0conduitIgnore the remainder of values in the source. Particularly useful when combined with .Subject to fusion Since 0.3.0conduitIgnore the remainder of values in the source. Particularly useful when combined with .Subject to fusion Since 0.3.0conduitA source that outputs no values. Note that this is just a type-restricted synonym for .Subject to fusion Since 0.3.0conduitA source that outputs no values. Note that this is just a type-restricted synonym for .Subject to fusion Since 0.3.0conduitRun a Pipe repeatedly, and output its result value downstream. Stops when no more input is available from upstream. Since 0.5.0conduitPipe to run repeatedly3jk3jk  Safe-Inferred  Safe-Inferred6jconduitsymlink to fileconduitsymlink to a directory   Safe-Inferred )*~conduitA buffer allocation strategy (buf0, nextBuf) 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 buf is lost as soon as possible, but the new buffer doesn't have to be allocated too early.conduit 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.conduitProvides a series of  ByteString4s until empty, at which point it provides an empty  ByteString.conduit0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusionconduit0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusionconduit&Generate a producer from a seed value.Subject to fusionconduit8Enumerate 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 fusionconduit?Produces an infinite stream of repeated applications of f to x.Subject to fusionconduitProduce an infinite stream consisting entirely of the given value.Subject to fusionconduitProduce a finite stream consisting of n copies of the given value.Subject to fusionconduit?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see .Subject to fusionconduitRepeatedly run the given action and yield all values it produces.Subject to fusionconduitRepeatedly run the given action and yield all values it produces.Subject to fusionconduitRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusionconduitRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusionconduit7Perform the given action n times, yielding each result.Subject to fusionconduit-Stream the contents of a file as binary data.conduitStream 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.conduitSame as  sourceHandle, but instead of allocating a new buffer for each incoming chunk of data, reuses the same buffer. Therefore, the  ByteStrings 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 ". 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 . The alternate name is a holdover from an older version, when ' was more polymorphic than it is today.conduit sourceHandle applied to stdin.Subject to fusionconduit+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> sinkList)[3,4,5]conduit8Drop a certain number of elements from a chunked stream.Note: you likely want to use it with monadic composition. See the docs for .conduit0Drop all values which match the given predicate.Note: you likely want to use it with monadic composition. See the docs for .conduitDrop all elements in the chunked stream which match the given predicate.Note: you likely want to use it with monadic composition. See the docs for .conduit,Monoidally combine all values in the stream.Subject to fusionconduit6Monoidally combine all elements in the chunked stream.Subject to fusionconduitA strict left fold.Subject to fusionconduit'A strict left fold on a chunked stream.Subject to fusionconduitApply the provided mapping function and monoidal combine all values.Subject to fusionconduitApply 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 fusionconduit4A strict left fold with no starting value. Returns  when the stream is empty.Subject to fusionconduitA 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.Subject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusionconduit0Check that all values in the stream return True.Subject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusionconduit:Check that all elements in the chunked stream return True.Subject 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.Subject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusionconduit9Check that at least one value in the stream returns True.Subject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusionconduitCheck that at least one element in the chunked stream returns True.Subject to shortcut logic: at the first True, consumption of the stream will stop.Subject to fusionconduit"Are all values in the stream True?6Consumption stops once the first False is encountered.Subject to fusionconduit,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered.Subject to fusionconduit"Are any values in the stream True?5Consumption stops once the first True is encountered.Subject to fusionconduit,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.Subject to fusionconduit$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 fusionconduitAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusionconduit5Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusionconduitAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusionconduitConsume 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 fusionconduitConsume 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 fusionconduitConsume all values from the stream and return as a list. Note that this will pull all values into memory.Subject to fusionconduitSink incoming values into a vector, growing the vector as necessary to fit more elements. f a >>= \() -> return a)Subject to fusionconduit Analog of  for lists, monadic.Subject to fusionconduit Analog of  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.conduitDecode 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.conduitStream 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 unsafe, 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 unsafe, 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 unsafe, 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 fusionconduitIncrementally execute builders and pass on the filled chunks as bytestrings.conduitSame as ', but input and output are wrapped in F.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!conduitA conduit that incrementally executes builders and passes on the filled chunks as bytestrings to an inner sink.> sinkList)[3,4,5]conduit8Drop a certain number of elements from a chunked stream.Note: you likely want to use it with monadic composition. See the docs for .conduit0Drop all values which match the given predicate.Note: you likely want to use it with monadic composition. See the docs for .conduitDrop all elements in the chunked stream which match the given predicate.Note: 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.conduitApply the provided mapping function and monoidal combine all values.conduitApply the provided mapping function and monoidal combine all elements of the chunked stream.conduit0Check that all values in the stream return True.Subject to shortcut logic: at the first False, consumption of the stream will stop.conduit:Check that all elements in the chunked stream return True.Subject to shortcut logic: at the first False, consumption of the stream will stop.conduit9Check that at least one value in the stream returns True.Subject to shortcut logic: at the first True, consumption of the stream will stop.conduitCheck that at least one element in the chunked stream returns True.Subject 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.conduitAre 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.conduitAre 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 , 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.conduitView the next element in the chunked stream without consuming it.conduit2Retrieve the last value in the stream, if present.conduitSame as , but returns a default value if none are available from the stream.conduit 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.conduitDecode 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: https://www.fpcomplete.com/user/snoyberg/library-documentation/vectorbuilderconduitmaximum allowed sizeconduitsize Safe-InferredT  =>?@ABCDEFGHIJKLMNOQTUZ[\]^cdfghilmnopqrstuvwxyz{|}~    !" !#$%&$%'()*()+(),-./-01-02-34-35-67-68-69-6:-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 c d d e f f g h h i j k j  l m n o p q q r r s t u v w x y z { | } ~            O P       I L M N  Q K W X Y Z                \[    [                                                                                                                                                     $ $$$$$$$$                                                 $conduit-1.3.5-Et8gg52Gj6jLDbatvG80T9 Data.ConduitConduitData.Conduit.InternalData.Conduit.ListData.Conduit.Internal.Fusion!Data.Conduit.Internal.List.StreamData.Conduit.Combinators.StreamData.Conduit.LiftData.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 runIdentityIdentityexceptions-0.10.4Control.Monad.CatchthrowM MonadThrowtransformers-0.5.6.2Control.Monad.Trans.Classlift MonadTrans(primitive-0.8.0.0-LlRUNeadwzL5iUsmiOkRZ1Control.Monad.Primitive primitive PrimState PrimMonad&resourcet-1.3.0-A6NymxaN5yD2guSinOmkB6Control.Monad.Trans.Resource runResourceT Data.Acquire withAcquireallocateAcquire%Control.Monad.Trans.Resource.Internal MonadResource ResourceTData.Acquire.Internal mkAcquireType mkAcquireReleaseExceptionReleaseExceptionWith ReleaseNormal ReleaseEarly ReleaseTypeAcquire,unliftio-core-0.2.1.0-LnlI9cWUdXt7RBg3vurrUqControl.Monad.IO.Unlift MonadUnliftIO withRunInIOPipe HaveOutput NeedInputDonePipeMLeftoverawaitawaitE awaitForeveryieldyieldMleftoverunconsM unconsEitherMbracketPidPpipepipeLrunPipeinjectLeftovers 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 mapInputM$$+$$++$$+-$=+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 unfoldEitherMuncons unconsEitheriterate replicate replicateMfoldfoldMfoldMapfoldMapMmapM_droptakeheadpeekmapmapMiterMmapMaybe mapMaybeM catMaybesconcat concatMap concatMapMconcatMapAccumscanlM mapAccumMscanscanMconcatMapAccumM mapFoldable mapFoldableMconsumechunksOfgroupBygroupOn1groupOnisolatefiltersinkNull 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 foldWhile 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 groupOn1CNonEmptyisolateC sinkNullC sourceNullCmempty ReadHandleopenFile closeFile readChunk FTFileSymFTDirectorySym unix-2.7.2.2System.Posix.Directory openDirStreamSystem.Posix.Directory.Common DirStreamcloseDirStreamFileTypeFTFile FTDirectoryFTOther readDirStream getFileTypeBuffer BuilderPopper yieldManyCGHC.Enumsucc0mono-traversable-1.0.15.3-L4RmTwqJZbV5C32lAoXj9hData.SequencestoChunksGHC.IO.Handle.TypesHandlecautiousAcquirecautiousCleanupGHC.IO.StdHandleswithBinaryFile>>foldl1C GHC.MaybeNothingfoldl1E Alternative sinkLazyC sinkVectorC sinkVectorNCsinkLazyBuilderCData.MonoTraversableonulllastECbytestring-0.11.3.1Data.ByteString.Internal ByteStringsplitOnUnboundedECunsafeFreezeBufferunsafeFreezeNonEmptyBufferupdateEndOfSlice sliceSizedefaultStrategy bufferSize allocBuffer reuseBuffer