F      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDENone $DLORT-Streaming versions of /Data.Conduit.Combinators.Internal.initReplicate.Streaming versions of ,Data.Conduit.Combinators.Internal.initRepeatFUtility function*GHIJKLMNOPQRSTUmaximum allowed size !"#$%&'()*+,-.F !"#$%&'()*+,-. !"#$%&'()*+,-.GHIJKLMNOPQRSTU !"#$%&'()*+,-.FNoneOTV[Acquire the seed value and perform the given action with it n times, yielding each result.Subject to fusion Since 0.2.1/[Acquire the seed value and perform the given action with it n times, yielding each result.Subject to fusion Since 0.2.10NOptimized version of initReplicate for the special case of connecting with a Sink. Since 0.2.1W[Acquire the seed value and perform the given action with it forever, yielding each result.Subject to fusion Since 0.2.11[Acquire the seed value and perform the given action with it forever, yielding each result.Subject to fusion Since 0.2.12KOptimized version of initRepeat for the special case of connecting with a Sink. Since 0.2.1V/0W12/012/012V/0W12None %&:<=OTX0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion Since 1.0.030Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors.Subject to fusion Since 1.0.04&Generate a producer from a seed value.Subject to fusion Since 1.0.058Enumerate from a value to a final value, inclusive, via Y.,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 1.0.06?Produces an infinite stream of repeated applications of f to x.Subject to fusion Since 1.0.07BProduce an infinite stream consisting entirely of the given value.Subject to fusion Since 1.0.08BProduce a finite stream consisting of n copies of the given value.Subject to fusion Since 1.0.09?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see Z.Subject to fusion Since 1.0.0[ARepeatedly run the given action and yield all values it produces.Subject to fusion Since 1.0.0:ARepeatedly run the given action and yield all values it produces.Subject to fusion Since 1.0.0\hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion Since 1.0.0;hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False.Subject to fusion Since 1.0.0<7Perform the given action n times, yielding each result.Subject to fusion Since 1.0.0=  specialized to ] to help with type inference.> sourceHandle applied to stdin.Subject to fusion Since 1.0.0?SCreate an infinite stream of random values, seeding from the system random number.Subject to fusion Since 1.0.0@UCreate a stream of random values of length n, seeding from the system random number.Subject to fusion Since 1.0.0AUCreate an infinite stream of random values, using the given random number generator.Subject to fusion Since 1.0.0BUCreate a stream of random values of length n, seeding from the system random number.Subject to fusion Since 1.0.0CrCreate an infinite stream of random values from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3DtCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3EtCreate an infinite stream of random values from an arbitrary distribution, using the given random number generator.Subject to fusion Since 1.0.3FtCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3GFStream 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. Since 1.0.0H2Deeply 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. Since 1.0.0I0Ignore a certain number of values in the stream. Since 1.0.0J8Drop a certain number of elements from a chunked stream. Since 1.0.0K0Drop all values which match the given predicate. Since 1.0.0LHDrop all elements in the chunked stream which match the given predicate. Since 1.0.0M,Monoidally combine all values in the stream.Subject to fusion Since 1.0.0N6Monoidally combine all elements in the chunked stream.Subject to fusion Since 1.0.0OA strict left fold.Subject to fusion Since 1.0.0P'A strict left fold on a chunked stream.Subject to fusion Since 1.0.0QDApply the provided mapping function and monoidal combine all values.Subject to fusion Since 1.0.0R\Apply the provided mapping function and monoidal combine all elements of the chunked stream.Subject to fusion Since 1.0.0^4A strict left fold with no starting value. Returns _ when the stream is empty.Subject to fusionS4A strict left fold with no starting value. Returns _ when the stream is empty.Subject to fusion`IA strict left fold on a chunked stream, with no starting value. Returns _ when the stream is empty.Subject to fusion Since 1.0.0a0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusion Since 1.0.0T0Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop.Subject to fusion Since 1.0.0U: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 fusion Since 1.0.0b9Check 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 fusion Since 1.0.0V9Check 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 fusion Since 1.0.0WCCheck 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 fusion Since 1.0.0X"Are all values in the stream True?6Consumption stops once the first False is encountered.Subject to fusion Since 1.0.0Y,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered.Subject to fusion Since 1.0.0Z"Are any values in the stream True?5Consumption stops once the first True is encountered.Subject to fusion Since 1.0.0[,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered.Subject to fusion Since 1.0.0\c$ly combine all values in the stream. Since 1.1.1]6Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0^BAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0_5Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0`AAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found.Subject to fusion Since 1.0.0d|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 Since 1.0.0a|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 Since 1.0.0bjConsume all values from the stream and return as a list. Note that this will pull all values into memory.Subject to fusion Since 1.0.0eZSink 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 Since 1.0.0cZSink 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 Since 1.0.0f2Sink 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 Since 1.0.0d2Sink 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 Since 1.0.0eJConvert incoming values to a builder and fold together all builder values. Defined as: foldMap toBuilder.Subject to fusion Since 1.0.0gSame 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 Since 1.0.0fSame 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 Since 1.0.0g7Consume and discard all remaining values in the stream.Subject to fusion Since 1.0.0hSame as await, but discards any leading h values. Since 1.0.0i2Take a single value from the stream, if available. Since 1.0.5jSame as iD, but returns a default value if none are available from the stream. Since 1.0.5k+Get the next element in the chunked stream. Since 1.0.0l7View the next value in the stream without consuming it. Since 1.0.0mAView the next element in the chunked stream without consuming it. Since 1.0.0i2Retrieve the last value in the stream, if present.Subject to fusion Since 1.0.0n2Retrieve the last value in the stream, if present.Subject to fusion Since 1.0.0oSame as nD, but returns a default value if none are available from the stream. Since 1.0.5j<Retrieve the last element in the chunked stream, if present.Subject to fusion Since 1.0.0p<Retrieve the last element in the chunked stream, if present.Subject to fusion Since 1.0.0q(Count how many values are in the stream.Subject to fusion Since 1.0.0r2Count how many elements are in the chunked stream.Subject to fusion Since 1.0.0s=Count how many values in the stream pass the given predicate.Subject to fusion Since 1.0.0tGCount how many elements in the chunked stream pass the given predicate.Subject to fusion Since 1.0.0u0Get the largest value in the stream, if present.Subject to fusion Since 1.0.0v:Get the largest element in the chunked stream, if present.Subject to fusion Since 1.0.0w1Get the smallest value in the stream, if present.Subject to fusion Since 1.0.0x;Get the smallest element in the chunked stream, if present.Subject to fusion Since 1.0.0y*True if there are no values in the stream.)This function does not modify the stream. Since 1.0.0z4True 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. Since 1.0.0{(Get the sum of all values in the stream.Subject to fusion Since 1.0.0|2Get the sum of all elements in the chunked stream.Subject to fusion Since 1.0.0},Get the product of all values in the stream.Subject to fusion Since 1.0.0~6Get the product of all elements in the chunked stream.Subject to fusion Since 1.0.0kFind the first matching value.Subject to fusion Since 1.0.0Find the first matching value.Subject to fusion Since 1.0.0-Apply the action to all values in the stream.Subject to fusion Since 1.0.07Apply the action to all elements in the chunked stream.Subject to fusion Since 1.0.0A monadic strict left fold.Subject to fusion Since 1.0.0/A monadic strict left fold on a chunked stream.Subject to fusion Since 1.0.0LApply the provided monadic mapping function and monoidal combine all values.Subject to fusion Since 1.0.0eApply the provided monadic mapping function and monoidal combine all elements in the chunked stream.Subject to fusion Since 1.0.0 specialized to ] to help with type inference.$Print all incoming values to stdout.Subject to fusion Since 1.0.0 sinkHandle applied to stdout.Subject to fusion Since 1.0.0 sinkHandle applied to stderr.Subject to fusion Since 1.0.01Apply a transformation to all values in a stream.Subject to fusion Since 1.0.0;Apply a transformation to all elements in a chunked stream.Subject to fusion Since 1.0.0GApply 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 fusion Since 1.0.0lApply 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 fusion Since 1.0.0Apply 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 fusion Since 1.0.0Apply 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 Since 1.0.0+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 fusion Since 1.0.0AStream 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 . Since 1.0.0<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with . Since 1.0.0RStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with . Since 1.0.0FConsume 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 ConduitMW 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". Since 1.0.0Same as , but for chunked streams. Since 1.0.0mFFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusion Since 1.0.0FFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values.Subject to fusion Since 1.0.09Keep only values in the stream passing a given predicate.Subject to fusion Since 1.0.0CKeep only elements in the chunked stream passing a given predicate.Subject to fusion Since 1.0.0$Map values as long as the result is Just. Since 1.0.0Break 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. Since 1.0.0n Analog of o for lists.Subject to fusion Since 1.0.6 Analog of o for lists.Subject to fusion Since 1.0.6pJ with a break condition dependent on a strict accumulator. Equivalently, q 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, q 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 Since 1.0.0r=Insert the given value between each two values in the stream.Subject to fusion Since 1.0.0=Insert the given value between each two values in the stream.Subject to fusion Since 1.0.0sUSliding 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 fusion Since 1.0.0USliding 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 fusion Since 1.0.0Split 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 )$Apply base64-encoding to the stream. Since 1.0.0TApply base64-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.0!Apply URL-encoding to the stream. Since 1.0.0_Apply lenient base64URL-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.0$Apply base16-encoding to the stream.Subject to fusion Since 1.0.0TApply base16-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.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 1.0.0CApply a monadic transformation to all elements in a chunked stream.Subject to fusion Since 1.0.0OApply 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 fusion Since 1.0.0tApply 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 fusion Since 1.0.0Apply 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 fusion Since 1.0.0uAKeep only values in the stream passing a given monadic predicate.Subject to fusion Since 1.0.0AKeep only values in the stream passing a given monadic predicate.Subject to fusion Since 1.0.0KKeep only elements in the chunked stream passing a given monadic predicate.Subject to fusion Since 1.0.01Apply 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 1.0.0v Analog of o for lists, monadic.Subject to fusion Since 1.0.6 Analog of o for lists, monadic.Subject to fusion Since 1.0.6wMonadic .Subject to fusionMonadic .Subject to fusion with an accumulator.Subject to fusion Since 1.0.0 Encode a stream of text as UTF8.Subject to fusion Since 1.0.0'Decode a stream of binary data as UTF8. Since 1.0.0lDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character. Since 1.0.0(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. Since 1.0.0Same as $, but operates on ASCII/binary data. Since 1.0.0AStream 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 fusion Since 1.0.0Same as $, but operates on ASCII/binary data.Subject to fusion Since 1.0.0xSplit 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 fusion Since 1.0.0Same as , but for ASCII/binary data.Subject to fusion Since 1.0.0Generally 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/vectorbuilder Since 1.0.0Consume 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. Since 1.0.0fRun 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.yzX3456789[:\;<=>?@countABcountCDcountEFcountGHFollow directory symlinksRoot directoryIJKLMNOP{QR^S`|aTUbVWXYZ[\]^_`dabecfmaximum allowed sizedmaximum allowed sizeegfghijklminojpqrstuvwxyz{|}~klmmaximum allowed sizenprs}tuvwxsize~ 3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3456789:;< = >?@ABCDEFGHIJKLMNOSPQRTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ yzX3456789[:\;<=>?@ABCDEFGHIJKLMNOP{QR^S`|aTUbVWXYZ[\]^_`dabecfdegfghijklminojpqrstuvwxyz{|}~klmnprs}tuvwx~None %&:<=OT0Yield each of the values contained by the given  MonoFoldable.9This will work on many data structures, including lists,  ByteStrings, and Vectors. Since 1.0.0&Generate a producer from a seed value. Since 1.0.08Enumerate 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. Since 1.0.0?Produces an infinite stream of repeated applications of f to x. Since 1.0.0BProduce an infinite stream consisting entirely of the given value. Since 1.0.0BProduce a finite stream consisting of n copies of the given value. Since 1.0.0?Generate a producer by yielding each of the strict chunks in a  LazySequence.For more information, see Z. Since 1.0.0ARepeatedly run the given action and yield all values it produces. Since 1.0.0hRepeatedly run the given action and yield all values it produces, until the provided predicate returns False. Since 1.0.07Perform the given action n times, yielding each result. Since 1.0.0 sourceHandle applied to stdin. Since 1.0.0SCreate an infinite stream of random values, seeding from the system random number. Since 1.0.0UCreate a stream of random values of length n, seeding from the system random number. Since 1.0.0UCreate an infinite stream of random values, using the given random number generator. Since 1.0.0UCreate a stream of random values of length n, seeding from the system random number. Since 1.0.0rCreate an infinite stream of random values from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3tCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3tCreate an infinite stream of random values from an arbitrary distribution, using the given random number generator.Subject to fusion Since 1.0.3tCreate a stream of random values of length n from an arbitrary distribution, seeding from the system random number.Subject to fusion Since 1.0.3FStream 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. Since 1.0.02Deeply 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. Since 1.0.00Ignore a certain number of values in the stream. Since 1.0.08Drop a certain number of elements from a chunked stream. Since 1.0.00Drop all values which match the given predicate. Since 1.0.0HDrop all elements in the chunked stream which match the given predicate. Since 1.0.0,Monoidally combine all values in the stream. Since 1.0.06Monoidally combine all elements in the chunked stream. Since 1.0.0A strict left fold. Since 1.0.0'A strict left fold on a chunked stream. Since 1.0.0DApply the provided mapping function and monoidal combine all values. Since 1.0.0\Apply the provided mapping function and monoidal combine all elements of the chunked stream. Since 1.0.00Check that all values in the stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop. Since 1.0.0:Check that all elements in the chunked stream return True.TSubject to shortcut logic: at the first False, consumption of the stream will stop. Since 1.0.09Check that at least one value in the stream returns True.SSubject to shortcut logic: at the first True, consumption of the stream will stop. Since 1.0.0CCheck 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. Since 1.0.0"Are all values in the stream True?6Consumption stops once the first False is encountered. Since 1.0.0,Are all elements in the chunked stream True?6Consumption stops once the first False is encountered. Since 1.0.0"Are any values in the stream True?5Consumption stops once the first True is encountered. Since 1.0.0,Are any elements in the chunked stream True?5Consumption stops once the first True is encountered. Since 1.0.0 Alternative$ly combine all values in the stream. Since 1.1.16Are any values in the stream equal to the given value?,Stops consuming as soon as a match is found. Since 1.0.0BAre any elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found. Since 1.0.05Are no values in the stream equal to the given value?,Stops consuming as soon as a match is found. Since 1.0.0AAre no elements in the chunked stream equal to the given element?,Stops consuming as soon as a match is found. Since 1.0.0|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. Since 1.0.0jConsume all values from the stream and return as a list. Note that this will pull all values into memory. Since 1.0.0ZSink 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. Since 1.0.02Sink 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. Since 1.0.0JConvert incoming values to a builder and fold together all builder values. Defined as: foldMap toBuilder. Since 1.0.0Same 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. Since 1.0.07Consume and discard all remaining values in the stream. Since 1.0.0Same as await, but discards any leading h values. Since 1.0.02Take a single value from the stream, if available. Since 1.0.5Same as D, but returns a default value if none are available from the stream. Since 1.0.5+Get the next element in the chunked stream. Since 1.0.07View the next value in the stream without consuming it. Since 1.0.0AView the next element in the chunked stream without consuming it. Since 1.0.02Retrieve the last value in the stream, if present. Since 1.0.0Same as D, but returns a default value if none are available from the stream. Since 1.0.5<Retrieve the last element in the chunked stream, if present. Since 1.0.0(Count how many values are in the stream. Since 1.0.02Count how many elements are in the chunked stream. Since 1.0.0=Count how many values in the stream pass the given predicate. Since 1.0.0GCount how many elements in the chunked stream pass the given predicate. Since 1.0.00Get the largest value in the stream, if present. Since 1.0.0:Get the largest element in the chunked stream, if present. Since 1.0.01Get the smallest value in the stream, if present. Since 1.0.0;Get the smallest element in the chunked stream, if present. Since 1.0.0*True if there are no values in the stream.)This function does not modify the stream. Since 1.0.04True 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. Since 1.0.0(Get the sum of all values in the stream. Since 1.0.02Get the sum of all elements in the chunked stream. Since 1.0.0,Get the product of all values in the stream. Since 1.0.0 6Get the product of all elements in the chunked stream. Since 1.0.0 Find the first matching value. Since 1.0.0 -Apply the action to all values in the stream. Since 1.0.0 7Apply the action to all elements in the chunked stream. Since 1.0.0 A monadic strict left fold. Since 1.0.0/A monadic strict left fold on a chunked stream. Since 1.0.0LApply the provided monadic mapping function and monoidal combine all values. Since 1.0.0eApply the provided monadic mapping function and monoidal combine all elements in the chunked stream. Since 1.0.0$Print all incoming values to stdout. Since 1.0.0 sinkHandle applied to stdout. Since 1.0.0 sinkHandle applied to stderr. Since 1.0.01Apply a transformation to all values in a stream. Since 1.0.0;Apply a transformation to all elements in a chunked stream. Since 1.0.0GApply 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. Since 1.0.0Apply 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. Since 1.0.0Apply 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. Since 1.0.0+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. Since 1.0.0AStream 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. Since 1.0.0<Stream all values downstream that match the given predicate.<Same caveats regarding downstream termination apply as with take. Since 1.0.0RStream all elements downstream that match the given predicate in a chunked stream.<Same caveats regarding downstream termination apply as with takeE. Since 1.0.0FConsume 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 ConduitMW 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". Since 1.0.0Same as  takeExactly, but for chunked streams. Since 1.0.0FFlatten out a stream by yielding the values contained in an incoming  MonoFoldable as individually yielded values. Since 1.0.0 9Keep only values in the stream passing a given predicate. Since 1.0.0!CKeep only elements in the chunked stream passing a given predicate. Since 1.0.0"$Map values as long as the result is Just. Since 1.0.0#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. Since 1.0.0$ Analog of  for lists. Since 1.0.6%"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. Since 1.0.0'=Insert the given value between each two values in the stream. Since 1.0.0(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. Since 1.0.0)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)+$Apply base64-encoding to the stream. Since 1.0.0,TApply base64-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.0-!Apply URL-encoding to the stream. Since 1.0.0._Apply lenient base64URL-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.0/$Apply base16-encoding to the stream. Since 1.0.00TApply base16-decoding to the stream. Will stop decoding on the first invalid chunk. Since 1.0.019Apply 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_. Since 1.0.02CApply a monadic transformation to all elements in a chunked stream. Since 1.0.03OApply 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. Since 1.0.04Apply 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. Since 1.0.05AKeep only values in the stream passing a given monadic predicate. Since 1.0.06KKeep only elements in the chunked stream passing a given monadic predicate. Since 1.0.071Apply 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) Since 1.0.08 Analog of  for lists, monadic. Since 1.0.69Monadic %.: concatMapM with an accumulator. Since 1.0.0; Encode a stream of text as UTF8. Since 1.0.0<'Decode a stream of binary data as UTF8. Since 1.0.0=lDecode a stream of binary data as UTF8, replacing any invalid bytes with the Unicode replacement character. Since 1.0.0>(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. Since 1.0.0?Same as line$, but operates on ASCII/binary data. Since 1.0.0@=Insert a newline character after each incoming chunk of data. Since 1.0.0ASame as unlines$, but operates on ASCII/binary data. Since 1.0.0BConvert 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. Since 1.0.0CSame as linesUnbounded, but for ASCII/binary data. Since 1.0.0DGenerally 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/vectorbuilder Since 1.0.0countcountcountcountFollow directory symlinksRoot directorymaximum allowed size      !"#maximum allowed size$%&'()*+,-./0123456789:;<=>?@ABCDsize =      !"#$%&'()*+,-./0123456789:;<=>?@ABCD      !"#$%&'()*+,-./0123456789:;<=>?@ABCDNone:E =      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE =        !"#$%&'()*+,-./0123456789:;<=>?@ABCD EE     !" !#$%&'()'*+'*,$%-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~LRXYZ[\]^_`az{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLJMNOPQRSTUVWXYZ [\]^_`abc def dghijk]lmn#' o(pq *+78;<rsstuvwxypz{pz|pz}pz~pzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpzpppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp'''''''''0conduit-combinators-1.1.2-JjUwc66mDKtGH9Wl9qCTXxConduitData.Conduit.CombinatorsData.Conduit.Combinators.Stream!Data.Conduit.Combinators.Internal$Data.Conduit.Combinators.UnqualifiedPreludescanlCLmapAccumbaseData.Functor.Identity runIdentityIdentityControl.Monad.IO.ClassliftIOMonadIO'exceptions-0.8.3-74UMKX8an841ULC0nHtYN7Control.Monad.CatchthrowM,monad-control-1.0.2.2-9aTLeaO4El6L4t2OM8GECcControl.Monad.Trans.ControlMonadBaseControl*conduit-extra-1.2.0-BCK2oJNEngg5G4PYYmyyQLData.Conduit.BinarysinkFile sinkIOHandle sinkHandlesourceIOHandle sourceHandle sourceFile MonadThrowtransformers-0.5.2.0Control.Monad.Trans.Class MonadTranslift.transformers-base-0.4.4-DPTfYkTApgo2fdoO6WqXzcControl.Monad.Base MonadBase&resourcet-1.1.9-C4iL7xe8foFJ5dtZR3u3WVControl.Monad.Trans.Resource runResourceT%Control.Monad.Trans.Resource.Internal MonadResource ResourceTliftBase yieldManySrepeatMS repeatWhileMSfoldl1SallSanyS sinkLazyS sinkVectorS sinkVectorNSsinkLazyBuilderSlastSlastESfindS concatMapS concatMapMSconcatSscanlSscanlMSmapAccumWhileSmapAccumWhileMS intersperseSslidingWindowSfilterMSsplitOnUnboundedESinitReplicateS initRepeatS initReplicateinitReplicateConnect initRepeatinitRepeatConnect yieldManyunfold enumFromToiteraterepeat replicate sourceLazyrepeatM repeatWhileM replicateM sourceFileBSstdin sourceRandom sourceRandomNsourceRandomGensourceRandomNGensourceRandomWithsourceRandomNWithsourceRandomGenWithsourceRandomNGenWithsourceDirectorysourceDirectoryDeepdropdropE dropWhile dropWhileEfoldfoldEfoldlfoldlEfoldMapfoldMapEfoldl1allallEanyanyEandandEororEasumelemelemEnotElemnotElemEsinkLazysinkList sinkVector sinkVectorN sinkBuildersinkLazyBuildersinkNull awaitNonNullheadheadDefheadEpeekpeekElastlastDeflastElengthlengthElengthIf lengthIfEmaximummaximumEminimumminimumEnullnullEsumsumEproductproductEfindmapM_mapM_EfoldMfoldMEfoldMapM foldMapME sinkFileBSprintstdoutstderrmapmapEomapE concatMap concatMapEtaketakeE takeWhile takeWhileE takeExactly takeExactlyEconcatfilterfilterEmapWhile conduitVector mapAccumWhileconcatMapAccum intersperse slidingWindow chunksOfEchunksOfExactlyE encodeBase64 decodeBase64encodeBase64URLdecodeBase64URL encodeBase16 decodeBase16mapMmapMEomapME concatMapMfilterMfilterMEiterMscanlMmapAccumWhileMconcatMapAccumM encodeUtf8 decodeUtf8decodeUtf8Lenientline lineAsciitakeExactlyUntilEunlines unlinesAsciisplitOnUnboundedElinesUnboundedlinesUnboundedAscii vectorBuilder mapAccumS 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 chunksOfCEchunksOfExactlyCE encodeBase64C decodeBase64CencodeBase64URLCdecodeBase64URLC encodeBase16C decodeBase16CmapMCmapMCEomapMCE concatMapMCfilterMC filterMCEiterMCscanlMCmapAccumWhileMCconcatMapAccumMC encodeUtf8C decodeUtf8CdecodeUtf8LenientClineC lineAsciiCunlinesC unlinesAsciiClinesUnboundedClinesUnboundedAsciiCvectorBuilderC withAcquirefmapS SplitState SplitDone SplitNoSepSlidingWindowState SWInitial SWSliding SWEarlyExitIntersperseState IFirstValue IGotValue IEmitValue ScanState ScanEnded ScanContinuesinitReplicateC initRepeatC yieldManyCGHC.Enumsucc/mono-traversable-1.0.4.0-CSZek4j3ndc4aYJqyoEacTData.SequencestoChunksbytestring-0.10.8.1Data.ByteString.Internal ByteStringfoldl1CGHC.BaseNothingfoldl1E Alternative sinkLazyC sinkVectorC sinkVectorNCsinkLazyBuilderCData.MonoTraversableonulllastECGHC.List'conduit-1.2.12.1-6b4TSFRWHoSApJNfxxMPJ4Data.Conduit.ListsplitOnUnboundedECS ofoldlPrime foldMaybeNullcodeWithonAwaityieldSaddEData.Conduit.LiftexecRWSCevalRWSCrunRWSCrwsC execRWSLC evalRWSLCrunRWSLCrwsLC execWriterC runWriterCwriterC execWriterLC runWriterLCwriterLC execStateC evalStateC runStateCstateC execStateLC evalStateLC runStateLCstateLC runReaderCreaderC runMaybeCmaybeC catchCatchC runCatchC catchErrorC runErrorCerrorC catchExceptC runExceptCexceptC distribute Data.Conduit runConduitResrunConduitPure.|fuseconnectData.Conduit.Internal.Conduit fuseUpstream fuseBothMaybefuseBothsequenceConduits=$$+-=$$++=$$+ sequenceSinkssequenceSourcescloseResumableSource$=+$$+-$$++$$+mapInputmapOutputMaybe mapOutput transPipe awaitForeveryieldOr addCleanupbracketP runConduitleftoveryieldMyieldawait=$==$$=$$ sourceToListpassthroughSink mergeSourcenewResumableConduitunwrapResumableConduit fuseLeftoversfuseReturnLeftoverstryChandleCcatchC toConsumer toProducernewResumableSourceunwrapResumableConduitMSourceProducerSinkConsumerResumableSourceResumableConduitFlushChunk ZipSource getZipSourceZipSink getZipSink ZipConduit getZipConduit Data.AcquireallocateAcquireData.Acquire.InternalwithEx mkAcquireType mkAcquire ReleaseType ReleaseEarly ReleaseNormalReleaseExceptionAcquire